Ivan's wiki

115200

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

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 'A' and 'X'. Don't release control while switching from 'A' to 'X'.

ABA problem

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

ABA problem ABA problem is a correctness hazard in lock-free code using compare-and-swap (CAS). CAS assumes that matching values mean nothing changed, but another thread can change a location from A to B and back to A between your read and your CAS, and CAS cannot detect this. This manifests concretely in lock-free stacks where a popped and re-pushed node can corrupt the stack structure.

Adiabatic theorem

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Adiabatic theorem The adiabatic theorem says that a quantum system started in an eigenstate of its Hamiltonian stays in the corresponding eigenstate as the Hamiltonian changes, provided the change is slow enough and the level never touches its neighbours. It is the formal version of an idea that is easy to state and easy to get wrong: go slowly and the system keeps up. What counts as slow is set by the energy gap, and that turns out to be the whole story.$H(t)$$$H(t)\,\lvert n(t)\rangle = E_n(t…

Amdahl's law

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

Amdahl's law Amdahl's law quantifies the maximum speedup from parallelization given a fixed problem size: if fraction $p$ is parallelizable and $(1-p)$ is sequential, maximum speedup is $S_{\max} = \frac{1}{1-p}$. The sequential fraction acts as a hard ceiling—adding more cores beyond a point yields diminishing returns.

Applying gates to $\lvert 0\rangle$ (Zero state)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

Applying gates to $\lvert 0\rangle$ (Zero state) Gate Matrix form Derivation I gate $I = \begin{pmatrix}1&0\\0&1\end{pmatrix}$ $I\lvert 0\rangle = \begin{pmatrix}1&0\\0&1\end{pmatrix}\begin{pmatrix}1\\0\end{pmatrix} = \begin{pmatrix}1\\0\end{pmatrix} = \lvert 0\rangle$ X gate $X = \begin{pmatrix}0&1\\1&0\end{pmatrix}$ $X\lvert 0\rangle = \begin{pmatrix}0&1\\1&0\end{pmatrix}\begin{pmatrix}1\\0\end{pmatrix} = \begin{pmatrix}0\\1\end{pmatrix} = \lvert 1\rangle$ Y gate $Y = \begin{pmatrix…

Arduino uno R4 WiFi

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

Arduino uno R4 WiFi Documentation: *

Array

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

Array An array is a fixed-size sequence of elements of the same type stored in contiguous memory. The index of an element determines its address: base + index * sizeof(element). This means any element is reachable in O(1) time without traversal, and the memory layout is cache-friendly — iterating over an array touches sequential cache lines rather than chasing pointers.

Atom Computing

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

Atom Computing Atom Computing builds computers on Neutral Atom qubits. Individual ytterbium atoms are trapped in a grid of optical tweezers, tightly focused laser beams that each hold one atom in place. Qubits live in long-lived nuclear spin states. Two-qubit gates work by briefly exciting a pair of nearby atoms to a Rydberg state, where their electron clouds get large enough to interact.

Atomics

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

Atomics Atomics are operations on shared variables that execute indivisibly even when multiple threads access the variable simultaneously. They replace multi-step operations (load, compute, store) with single hardware instructions, preventing lost updates. C11's

B+ tree

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

B+ tree A B+ tree is a variant of the B-tree where all values are stored in the leaf nodes and internal nodes hold only keys used for routing. Leaf nodes are linked together in a sorted doubly linked list. This distinction has a significant practical effect: range queries traverse only the leaf layer rather than the entire tree, and all records are equidistant from the root, giving uniform access time.

B-tree

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

B-tree A B-tree is a self-balancing search tree generalised from a binary search tree to allow more than two children per node. Each node holds between $t-1$ and $2t-1$ keys (where $t \geq 2$ is the minimum degree), sorted in order. A node with $k$ keys has $k+1$ child pointers. All leaves are at the same depth, so the tree is perfectly height-balanced, and the height is O(log n).

List of internal bash shell commands

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

List of internal bash shell commands

Basis state

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

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…

Bell state (Qiskit)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

Bell state (Qiskit) Bell states implementation using Qiskit. All four Bell states are prepared from $\lvert 00\rangle$ using a Hadamard gate and a CX gate, with optional single-qubit corrections. from qiskit import QuantumCircuit from qiskit.quantum_info import Statevector def bell(z_flip=False, x_flip=False): qc = QuantumCircuit(2) qc.h(0) qc.cx(0, 1) if z_flip: qc.z(0) # relative phase flip if x_flip: qc.x(1) # bit flip on second qubit return qc p…

Bell states

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

Bell states Bell states are the four maximally entangled two-qubit states, named after physicist John Bell. They form an orthonormal basis for the two-qubit Hilbert space $\mathbb{C}^4$ and are the canonical examples of quantum entanglement. No product state can approximate them without a dramatic increase in entropy.$$\lvert\Phi^+\rangle = \frac{1}{\sqrt{2}}(\lvert 00\rangle + \lvert 11\rangle) \qquad \lvert\Phi^-\rangle = \frac{1}{\sqrt{2}}(\lvert 00\rangle - \lvert 11\rangle)$$$$\lvert\Psi^+…

Bespoke algorithm

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

Bespoke algorithm Bespoke algorithm is a custom lock-free data structure designed for one specific use case rather than a general-purpose structure. By exploiting known constraints (single producer, fixed capacity, or known access patterns), a bespoke design eliminates overhead that a general-purpose structure carries for flexibility.

Binary tree

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

Binary tree A binary tree is a hierarchical structure where each node holds a value and has at most two children, called left and right. The node with no parent is the root. Nodes with no children are leaves. The height of a tree is the number of edges on the longest path from root to leaf; a tree with n nodes has height between O(log n) (balanced) and O(n) (degenerate — essentially a linked list).

Bloch sphere

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

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…

Born rule

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

Born rule Born rule is a postulate in quantum mechanics that gives an interpretation of probability amplitudes. Namely, the 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 — according to the Born rule — equals the modulus squared of the probability amplitude $c$$$P_i = |c|^2$$$\lvert\psi\rangle$$a\in\mathbb{C}$$\lvert 0\rangle$$b\in\mathbb{C}$$\…

C bit fields

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

C bit fields C bit fields pack individual bits into struct members, saving memory when many boolean or small-range fields are needed. Declare with unsigned type : nbits to allocate exactly N bits for the field. Use bit fields for hardware registers, flags, or tight memory constraints.

C compound literals

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T11:41:47+00:00

C compound literals C compound literals (C99) create anonymous temporary objects with specified values: (Type){...}. Use them to pass structs to functions without named variables, or initialize data in expressions. Use compound literals for convenient inline struct/array passing without temporary variables.

C designated initializers

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T11:41:47+00:00

C designated initializers C designated initializers (C99) let you initialize struct/array members by name or index instead of in declaration order. Write struct Foo x = {.field = value} or int arr[] = {[5] = 10} to set specific fields without touching others.

C do-while-0

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T11:41:17+00:00

C do-while-0 C do-while-0 is an idiom using do { ... } while(0) to create a single-iteration loop that allows break to exit cleanly. It's used in macros to ensure multiple statements execute as a unit, or to allow early exit without goto or nested conditionals.

C duff's device

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C duff's device C Duff's device is a loop unrolling technique that combines a switch statement inside a while loop, allowing the loop condition and case labels to interact. It eliminates loop overhead by processing multiple iterations per loop cycle, originally invented for fast memory copying.

C exit status

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C exit status Exit status is an integer code (0-255) returned by a program to indicate success or failure. A return value of 0 means success (EXIT_SUCCESS); any non-zero value indicates failure. The shell stores the exit status in $? for inspection with

C flexible array members

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T11:41:42+00:00

C flexible array members C flexible array members (FAM) allow a struct to have a variable-length array as its last member with size specified at runtime. Declare as type array[] with no size; allocate the struct plus extra space for array data. Use FAM for variable-sized data structures without separate pointer indirection.

C function attributes

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

C function attributes C function attributes (GCC/Clang) use __attribute__ to annotate functions with metadata: __attribute__((noreturn)) for functions that never return, __attribute__((pure)) for side-effect-free functions, __attribute__((constructor))

C function macro

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C function macro Function macro is a preprocessor macro that looks and behaves like a function call. Arguments must be wrapped in parentheses to preserve precedence during substitution. Multi-statement function macros should use do { ... } while (0)

C function pointers

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

C function pointers C function pointers are pointers to functions, allowing callbacks, dispatch tables, and strategy patterns. Function pointers enable runtime dispatch without switch statements, making code extensible. Use function pointers for callbacks, plugin systems, and decoupling behavior from callers.

C goto error handling

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

C goto error handling C goto error handling uses goto labels to centralize cleanup code, avoiding nested error handling and ensuring resources are freed consistently. Each operation jumps to the appropriate cleanup label on error, executing only the necessary cleanup steps in reverse order.

C header guard

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C header guard Header guard is a C/C++ pattern that prevents multiple inclusion of the same header file by wrapping declarations in preprocessor conditionals. The pattern uses #ifndef, #define, and #endif to ensure declarations are processed only once, even if the header is included multiple times.

C headers

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

C headers C headers offer an interface to the C standard library. List of headers * * * * * * * * * * * * * * * * * * * * * * * * * * * * * …

C main() return

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

C main() return main() return value is the program's C exit status, communicated to the shell via the $? variable. Returning 0 indicates success (EXIT_SUCCESS); non-zero indicates failure (EXIT_FAILURE, typically 1). The shell can check this status with echo $? or use it in conditionals and pipelines.

C memory alignment

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

C memory alignment C memory alignment refers to the byte offset where data types must start. Structs have padding to align fields, and _Alignof queries alignment requirements. Proper alignment improves performance (cache lines, SIMD) and is required by hardware.

C pragma directives

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

C pragma directives C pragma directives use #pragma to send compiler-specific instructions. Common pragmas: #pragma once (include guard), #pragma pack (struct packing), #pragma GCC optimize (optimization level), #pragma omp (OpenMP). Pragmas are non-standard; behavior depends on compiler.

C pragma once

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T17:24:15+00:00

C pragma once #pragma once is a non-standard preprocessor directive that prevents multiple inclusion of a header file. It's simpler than header guards and achieves the same goal, though it's not officially part of the C standard. Modern compilers universally support

C restrict qualifier

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T11:41:45+00:00

C restrict qualifier C restrict qualifier (C99) tells the compiler that a pointer is the only way to access that memory during its lifetime. Enables aggressive optimization assuming no aliasing. Declare as int * restrict ptr to promise no other pointers reference the same data.

C standard library

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

C standard library C standard library is the core set of headers and functions always linked into C programs, providing essential utilities like I/O (), memory management (), string handling (), and math operations (

C static assertions

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T11:41:50+00:00

C static assertions C static assertions use _Static_assert(condition, "message") (C11) to verify compile-time constraints. If the condition is false, compilation fails with the message. Use for checking sizeof, alignment, configuration invariants.

C tail call optimization

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T11:41:52+00:00

C tail call optimization C tail call optimization (TCO) is a compiler optimization where a function's final call becomes a jump, reusing the same stack frame. Recursive functions calling themselves at the end convert from O(n) stack space to O(1). Optimizers enable TCO with -O2 or higher; not guaranteed.

C token pasting

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T11:41:48+00:00

C token pasting C token pasting uses the ## preprocessor operator to concatenate tokens into a single token. Use #name (stringification) to convert a token to a string. Combined, these enable powerful metaprogramming and code generation. Use token pasting in X macros and generic code generators; stringification for debug output.

C type punning

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T11:41:44+00:00

C type punning C type punning is reinterpreting a value as a different type via pointers or unions. Converting a float to its bit representation or accessing struct fields as raw bytes uses type punning. Undefined behavior if types have incompatible alignment.

C variadic macros

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T11:41:41+00:00

C variadic macros C variadic macros (C99) accept a variable number of arguments using __VA_ARGS__. They enable flexible printf-like logging, assertion macros, and generic utilities without separate macro definitions for each argument count. Use variadic macros for debug logging, flexible error handling, or type-generic operations.

C VLA

Anonymous (anonymous@undisclosed.example.com) — 2026-08-25T00:19:32+00:00

C VLA C VLA (Variable Length Arrays) (C99) lets you declare arrays with size determined at runtime: int arr[n] where n is computed. VLAs are stack-allocated; use for temporary arrays when size isn't known at compile time. Avoid large VLAs (stack overflow risk); use malloc for large/long-lived arrays.

C volatile qualifier

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T11:41:46+00:00

C volatile qualifier C volatile qualifier tells the compiler to never optimize away memory accesses. Declare as volatile int x to prevent caching in registers. Used for hardware registers, shared memory, signal handlers, or any data that can change outside program control.

C weak symbols

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T11:41:49+00:00

C weak symbols C weak symbols are linker-level symbols that can be overridden. Declare a function or variable __attribute__((weak)) (GCC/Clang) to allow another compilation unit to provide a strong override. Useful for plugin systems, default implementations, or optional features.

C X macros

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T11:41:40+00:00

C X macros C X macros are a metaprogramming technique where a macro is defined to represent a list, then included multiple times with different expansions to generate repetitive code. The same list definition generates enums, string arrays, case statements, and parser tables without manual duplication.

Cache coherence

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

Cache coherence Cache coherence is the guarantee that all cores see a single, consistent view of memory despite each core maintaining its own private cache. Without it, one core's write to a cached variable could be invisible to another core's read, violating fundamental correctness.

Cache directory protocols

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

Cache directory protocols Directory-based protocols implement cache coherence without a broadcast bus by explicitly tracking which cores hold each cache line. On a write, the directory is consulted to identify which cores need invalidation, and messages are sent only to actual sharers instead of broadcasting to all cores.

Cache snoopy protocols

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

Cache snoopy protocols Snoopy protocols implement cache coherence over a shared bus: every cache controller watches (“snoops”) all bus transactions regardless of origin and reacts if the address concerns a line it holds. Coherence emerges from every cache independently applying the same rules to the same broadcast traffic, with no central coordinator.

Cache

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

Cache Cache is fast on-chip memory between the CPU and main memory, holding recently used data. Caches exploit temporal locality (reuse) and spatial locality (adjacent access), organized in hierarchy: L1 (~1KB, ~1ns), L2 (~256KB, ~7ns), L3 (~20MB, ~100ns), memory (~100ns+). Cache lines (64 bytes) are the unit of transfer.

Canonical states

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

Canonical states Canonical states are the six single-qubit states corresponding to the six cardinal points of the Bloch sphere — the $\pm z$, $\pm x$, and $\pm y$ poles. They are the eigenstates of the three Pauli operators $Z$, $X$, $Y$ and are the most frequently encountered states in single-qubit quantum computing.$\pm z$$\lvert 0\rangle$$\lvert 1\rangle$$$\lvert 0\rangle = \begin{pmatrix}1\\0\end{pmatrix} \qquad \lvert 1\rangle = \begin{pmatrix}0\\1\end{pmatrix}$$$\pm x$$\lvert +\rangle$$\l…

Categorical quantum mechanics

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:37:15+00:00

Categorical quantum mechanics Categorical quantum mechanics formalizes quantum theory using category theory: quantum systems are objects, processes are morphisms. States are morphisms from scalars to Hilbert spaces; evolution is morphism composition. The framework provides string diagram calculus for visualizing and simplifying quantum circuits and proofs. Foundational for quantum error correction, quantum computing theory, and graphical calculi like ZX calculus.

CCX (Toffoli) gate

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

CCX (Toffoli) gate CCX gate (doubly-controlled X, also called Toffoli gate or CCNOT) is a three-qubit gate that flips the target qubit if and only if both control qubits are $\lvert 1\rangle$. It was introduced by Tommaso Toffoli in 1980 and is the key building block for reversible classical computation inside a quantum circuit.$\lvert a, b, c\rangle \mapsto \lvert a, b, c \oplus (a \wedge b)\rangle$$\oplus$$\wedge$$8 \times 8$$\lvert 000\rangle$$\lvert 111\rangle$$$\text{CCX} = \begin{pmatrix}…

CCZ gate

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

CCZ gate CCZ gate (doubly-controlled Z) is a three-qubit gate that applies a Pauli Z to the target qubit if and only if both control qubits are $\lvert 1\rangle$, and does nothing otherwise. Because Z acts as a phase flip, the CCZ gate is fully symmetric: any permutation of the three qubits produces the same unitary.$\lvert a, b, c\rangle \mapsto (-1)^{a \wedge b \wedge c}\lvert a, b, c\rangle$$\lvert 111\rangle$$8 \times 8$$\lvert 000\rangle$$\lvert 111\rangle$$$\text{CCZ} = \begin{pmatrix} 1&…

Circular buffer

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

Circular buffer A circular buffer (also called a ring buffer) is a fixed-capacity Queue backed by a flat Array with two indices: a read head and a write head. When either index reaches the end of the array it wraps back to zero, making the array appear circular. This gives O(1) enqueue and dequeue with no allocation and no data movement, at the cost of a fixed maximum size.

CMake basics

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

CMake basics CMake is a build system generator: it reads CMakeLists.txt and generates build files for your platform (Makefiles, Ninja, Visual Studio, etc.). Run cmake to configure, then use the generated build system to compile. $ mkdir build && cd build $ cmake .. # configure (reads CMakeLists.txt from parent) $ cmake --build . # build using generated files $ cmake --build . -v # verbose: show compiler commands $ cmake --build . --target test # r…

CMake cmakelists.txt

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

CMake cmakelists.txt CMakeLists.txt is the build configuration file. It describes what to build, where sources are, dependencies, and build options. Written in CMake's scripting language (imperative, case-insensitive commands). Minimal example: cmake_minimum_required(VERSION 3.20) project(MyApp) add_executable(myapp main.cpp)

CMake conditionals and loops

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

CMake conditionals and loops if(condition)...endif() runs code conditionally. foreach(item IN LISTS mylist)...endforeach() loops over a list. Control flow in CMake is straightforward but the condition syntax is unusual. Conditionals: if(DEFINED MY_VAR) message(STATUS "MY_VAR is defined") endif() if(CMAKE_BUILD_TYPE STREQUAL "Debug") target_compile_options(myapp PRIVATE -g) endif()

CMake executables and libraries

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

CMake executables and libraries add_executable(name source1.cpp source2.cpp) builds an executable from source files. add_library(name source1.cpp ...) builds a library — either static (.a, .lib) or shared (.so, .dll) depending on the type specified.

CMake finding dependencies

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

CMake finding dependencies find_package(PackageName) searches for an installed package and creates targets to link against. CMake searches standard paths, CMAKE_PREFIX_PATH, and system paths for package metadata (typically .cmake files). Basic usage:

CMake functions and macros

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

CMake functions and macros function(name arg1 arg2) ... endfunction() defines a reusable function. macro(name arg1 arg2) ... endmacro() defines a macro. Functions create a new scope; variables set inside don't escape. Macros are text substitution; they don't create scope.

CMake generators

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

CMake generators A generator is the backend build system CMake produces. CMake reads CMakeLists.txt and generates build files for your chosen generator: Makefiles, Ninja, Visual Studio, Xcode, etc. Use -G to select: cmake -G "Unix Makefiles" .. cmake -G "Ninja" .. cmake -G "Visual Studio 16 2019" ..

CMake installation

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

CMake installation install(TARGETS target DESTINATION bin) installs a target to the specified directory under CMAKE_INSTALL_PREFIX. The default prefix is /usr/local on Unix. Run cmake --install . to install after building. Installing executables: add_executable(myapp main.cpp) install(TARGETS myapp DESTINATION bin)

CMake linking

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

CMake linking target_link_libraries(target PRIVATE|PUBLIC|INTERFACE libs) links a target to libraries. The keyword controls visibility: PRIVATE (only target needs it), PUBLIC (target and consumers), INTERFACE (only consumers). Basic linking: add_executable(myapp main.cpp) target_link_libraries(myapp PRIVATE mylib)

CMake modern practices

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

CMake modern practices Modern CMake (3.12+) is target-based: apply settings to individual targets with target_* commands, not globally. This produces cleaner, more maintainable builds and avoids side effects. Target-based approach: # GOOD: target-specific settings add_executable(myapp main.cpp) target_include_directories(myapp PRIVATE include/) target_compile_options(myapp PRIVATE -Wall -Wextra) target_link_libraries(myapp PRIVATE mylib) # BAD: global settings (affects all targets) include_…

CMake projects and targets

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

CMake projects and targets A project is declared with project(name), and targets are the build artifacts you create — executables, libraries, or custom outputs. Each target has properties (source files, include paths, linked libraries, compiler flags). In modern CMake, you apply settings to targets, not globally.

CMake subdirectories

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

CMake subdirectories add_subdirectory(subdir) includes another CMakeLists.txt from a subdirectory, creating a new scope for variables. Targets declared in subdirectories are visible in the parent, but variables are not (unless explicitly propagated with

CMake testing

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

CMake testing enable_testing() activates testing support. add_test(NAME name COMMAND cmd) registers a test that CMake/CTest will run. Tests are commands; their exit code determines pass (0) or fail (non-zero). Basic setup: cmake_minimum_required(VERSION 3.20) project(MyApp) enable_testing() add_executable(test_app test.cpp) add_test(NAME MyTest COMMAND test_app)

CMake variables

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

CMake variables set(VAR value) sets a variable in CMake. Access it with ${VAR}. Variables have scope: local (in current file or directory), parent scope (propagate up to including CMakeLists.txt), or cache (persistent across runs, visible in the CMake GUI).

CMake

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

CMake CMake is a build system generator. It reads a project description in CMakeLists.txt and generates native build files (Makefiles, Ninja, Visual Studio projects, etc.) for your platform. This solves portability—describe targets and dependencies abstractly, and CMake generates platform-specific build recipes.

CX gate (CUDA-Q)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

CX gate (CUDA-Q) CX gate implementation using CUDA-Q. The example prepares the Bell state $\lvert\Phi^+\rangle = \frac{1}{\sqrt{2}}(\lvert 00\rangle + \lvert 11\rangle)$. // Compile: nvq++ main.cpp -o main // Run: ./main #include struct kernel { __qpu__ void operator()() { cudaq::qvector<2> q; h(q[0]); // |00> -> |+0> cx(q[0], q[1]); // CX -> Bell state |Phi+> mz(q); } }; int main() { auto counts = cudaq::sample(kernel{}); …

CX gate (cuStateVec)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

CX gate (cuStateVec) CX gate implementation using cuStateVec. The example prepares the Bell state $\lvert\Phi^+\rangle = \frac{1}{\sqrt{2}}(\lvert 00\rangle + \lvert 11\rangle)$. // Compile: nvcc main.cu -o main -lcustatevec // Run: ./main #include #include #include #include int main() { const int nQubits = 2; const int dim = 1 << nQubits; cuDoubleComplex h_sv[4] = {{1,0},{0,0},{0,0},{0,0}}; // |00> cuDoubleComplex *d_…

CX gate (Qiskit)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

CX gate (Qiskit) CX gate implementation using Qiskit. The example prepares the Bell state $\lvert\Phi^+\rangle = \frac{1}{\sqrt{2}}(\lvert 00\rangle + \lvert 11\rangle)$. from qiskit import QuantumCircuit from qiskit.quantum_info import Statevector qc = QuantumCircuit(2) qc.h(0) # |00> -> |+0> qc.cx(0, 1) # CX: control=q0, target=q1 -> Bell state print(Statevector(qc)) # Statevector([0.70710678+0.j, 0.+0.j, 0.+0.j, 0.70710678+0.j], dims=(2, 2))

List of coreutils commands

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

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

$\mathbb{CP}^1$

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

$\mathbb{CP}^1$ Complex projective line (or $\mathbb{CP}^1$) is the space in which pure qubit states live. It is defined as the quotient of $\mathbb{C}^2 \setminus \{0\}$ by $\mathbb{C}^\times$. $$\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$. That's the Hilbert space in which all qubit state v…

C++ ADL

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

C++ ADL ADL (Argument-Dependent Lookup) is the rule that when calling a function with unqualified name, the compiler searches for candidates not just in local and global scopes but also in the namespaces of the function's arguments. This allows writing

C++ concepts

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C++ concepts Concepts (C++20) are compile-time predicates that check whether a type satisfies a set of requirements (methods, types, operations). They replace ad-hoc SFINAE and enable_if, providing clearer, more readable template constraints. A template with a

C++ const correctness

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C++ const correctness Const correctness means using const to document and enforce which functions and pointers should not modify their targets. A const member function promises not to modify the object, and a const parameter or reference promise the same to callers. This enables compiler checking and clarifies intent.

C++ constexpr

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

C++ constexpr constexpr marks a function, variable, or object as evaluable at compile time. A constexpr function can be called with compile-time constants to produce compile-time results, or with runtime values to execute as normal code. Variables declared

C++ copy-and-SWAP

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

C++ copy-and-SWAP Copy-and-swap is an idiom for implementing exception-safe copy assignment: copy the argument into a temporary, swap the temporary's contents with this object's, and let the temporary (holding the old data) be destroyed. This guarantees strong exception safety because the swap itself cannot fail.

C++ copy elision

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C++ copy elision Copy elision is a compiler optimization that eliminates unnecessary copy or move operations when a temporary object is constructed directly into its destination. In C++17 and later, copy elision is guaranteed in certain contexts (like returning a temporary from a function), making it semantically part of the language, not just an optimization.

C++ CRTP

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

C++ CRTP CRTP (Curiously Recurring Template Pattern) is a static polymorphism technique where a derived class passes itself as a template parameter to its base class. This enables zero-overhead polymorphism without virtual functions by allowing the base to call derived implementations at compile time.

C++ dependent names

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C++ dependent names Dependent names are names in template code that depend on template parameters. When a dependent name is ambiguous (could be a type or value), the compiler assumes it's a value unless declared with typename. Writing typename T::value_type

C++ empty base optimization

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C++ empty base optimization Empty base optimization (EBO) is a compiler technique where an empty base class takes no space in the derived object. Since an empty class has size 1 (to give it a unique address), deriving from it would normally add 1 byte to the derived object; EBO allows the derived object to have the same size as if the base didn't exist.

C++ erase-remove

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C++ erase-remove Erase-remove is the idiomatic way to remove elements matching a condition from a container: remove moves matching elements to the end and returns a new end iterator, then erase removes them. This avoids iterator invalidation issues and works with all standard containers.

C++ evaluation order

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C++ evaluation order Evaluation order defines in which order operands of an operator are evaluated. Before C++17, most operators had unspecified evaluation order, leading to undefined behavior in code like f(a++) + f(b++) where the order of side effects was unpredictable. C++17 specified the order for most operators, eliminating many pitfalls.

C++ exception safety

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C++ exception safety Exception safety describes guarantees a function makes about state if an exception is thrown. The three levels are: basic safety (invariants held, no leaks), strong safety (transaction-like: either succeeds or state unchanged), and nothrow safety (never throws). RAII and smart pointers help achieve these guarantees automatically.

C++ forwarding references

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C++ forwarding references Forwarding references (also called universal references) use the syntax T&& where T is a deduced template parameter, allowing a function to accept both lvalues and rvalues and preserve their value category. With function template argument deduction and reference collapsing rules,

C++ inline keyword

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

C++ inline keyword inline keyword marks a function to permit multiple definitions across translation units and allows the compiler to consider inlining (replacing the call with the function body). Today, inline is mainly for allowing definitions in headers; the actual inlining decision is made by the optimizer regardless of the keyword.

C++ integer promotions

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C++ integer promotions Integer promotions are automatic type conversions where smaller integer types (bool, char, short) are converted to int or unsigned int in arithmetic operations. This is an implicit conversion rule from the C standard that C++ inherits, often causing surprises when arithmetic on

C++ internal linkage

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C++ internal linkage Internal linkage means a symbol (function, variable, or type) is visible only within its translation unit and not to other .cpp files. Declaring with static or in an anonymous namespace gives internal linkage. This prevents linker conflicts and allows using the same name in different translation units.

C++ iterator invalidation

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C++ iterator invalidation Iterator invalidation occurs when a container operation (like insert, erase, push_back, or resize) makes existing iterators or references unsafe to use. Different containers have different invalidation rules: vector invalidates on reallocation;

C++ lambda captures

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C++ lambda captures Lambda captures are the mechanism by which lambdas access variables from their enclosing scope. Capture by value [x] copies the variable; capture by reference [&x] refers to the original. Default capture [=] or [&] captures all variables in value or reference form;

C++ logical constness

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C++ logical constness Logical constness is the principle that a const member function doesn't change the object's observable state, even if it modifies internal state (like a cache). The mutable keyword marks members that can be modified by const functions, indicating they don't affect observable behavior.

C++ most vexing parse

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C++ most vexing parse Most vexing parse is the surprising rule that in contexts ambiguous between a declaration and a temporary, the compiler interprets it as a declaration. For example, Widget w(Widget()); declares w as a function returning Widget, not a

C++ move semantics

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C++ move semantics Move semantics let an object transfer ownership of internal resources to another object instead of duplicating them. When the source is an rvalue (temporary or result of std::move), the compiler picks a move constructor instead of copying, stealing resources and leaving the source empty.

C++ name hiding

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C++ name hiding Name hiding occurs when a derived class member function has the same name as a base class member function but different parameters. The derived function hides all base functions with that name, even overloads, making them inaccessible through the derived object unless explicitly qualified.

C++ name mangling

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C++ name mangling Name mangling is how C++ compilers encode function and variable names to support overloading and namespaces. The mangled symbol encodes the namespace, class, function name, and parameter types—e.g., Hello::World::add(int, int)

C++ narrowing conversions

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C++ narrowing conversions Narrowing conversions are implicit type conversions that may lose information, like converting a larger integer type to a smaller one or double to int. These are allowed in traditional initialization but prohibited in brace initialization (

C++ noexcept

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

C++ noexcept noexcept is a specifier declaring that a function will not throw exceptions (or will terminate if it does). A noexcept function enables compiler optimizations and is required for strong exception safety guarantees in moves and swaps. Misusing

C++ object layout

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C++ object layout Object layout describes how a class's members are arranged in memory. The standard guarantees that non-static member variables are laid out in declaration order and that empty base classes may be optimized away. Virtual function pointers (vtable pointers) are typically stored at the start or end of the object, and alignment padding is added as needed.

C++ object slicing

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C++ object slicing Object slicing occurs when a derived class object is copied into a base class object by value, silently discarding derived-class members. The code compiles and runs without error, but loses data and polymorphic behavior. Prevent slicing by passing polymorphic objects by reference or pointer, never by value.

C++ one-definition rule

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C++ one-definition rule One-definition rule (ODR) states that a function, variable, or type can have only one definition across the entire program, though declarations can be multiple. Violating ODR causes linker errors or undefined behavior. Templates,

C++ overload resolution

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C++ overload resolution Overload resolution is the process where the compiler selects the best-matching function from a set of candidates. Candidates are ranked by how well their parameter types match the call's arguments: exact match beats conversion,

C++ partial specialization

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C++ partial specialization Partial specialization allows template classes (not functions) to define specialized versions for particular template parameter patterns. For example, a template class can have a separate specialization for pointer types or for template types, enabling different implementations for different type categories.

C++ perfect forwarding

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C++ perfect forwarding Perfect forwarding is the technique of using forwarding references and std::forward to write a template function that accepts arguments and passes them to another function while preserving their value categories (lvalue vs. rvalue). This avoids unnecessary copies and ensures move operations happen when appropriate.

C++ pimpl

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C++ pimpl Pimpl (Pointer to Implementation) is a design pattern that hides implementation details behind a pointer, reducing compilation dependencies and enabling binary compatibility across library versions. The public header declares only the interface; the actual implementation lives in a separate private class.

C++ RAII

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

C++ RAII RAII (Resource Acquisition Is Initialization) ties resource lifetimes to object lifetimes: acquiring a resource (opening a file, allocating memory, locking a mutex) happens in a constructor, and releasing it happens in the destructor. Resources are automatically released when the object goes out of scope, eliminating manual cleanup and preventing leaks.

C++ reference lifetime extension

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C++ reference lifetime extension Reference lifetime extension is a special rule where binding a temporary to a const reference extends the temporary's lifetime to the lifetime of the reference. This allows safely using temporary objects in references without dangling references.

C++ rule of five

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C++ rule of five Rule of five states that if a class defines any of the destructor, copy constructor, copy assignment, move constructor, or move assignment, it should define all five to ensure correct resource management. Without explicit definitions, the compiler generates defaults that may not handle custom resources correctly.

C++ rule of zero

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C++ rule of zero Rule of zero states that if a class manages resources correctly via RAII, it should define no special member functions at all—not destructor, copy constructor, copy assignment, move constructor, or move assignment. The compiler's defaults work correctly when members are themselves RAII-compliant (e.g.,

C++ self-assignment

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C++ self-assignment Self-assignment is when an object is assigned to itself: a = a. Without defensive checks, a naive copy assignment operator that deletes the old data before copying the new data will delete the source data and then try to copy from it, causing undefined behavior.

C++ sfinae

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C++ sfinae SFINAE (Substitution Failure Is Not An Error) is the rule that when template argument substitution produces an invalid type or expression during overload resolution, that candidate is silently removed from consideration rather than causing a compile error.

C++ shared_ptr

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

C++ shared_ptr shared_ptr is a reference-counted smart pointer that allows multiple owners to share ownership of the same object. The object is automatically deleted when the last shared_ptr is destroyed. Use shared_ptr when multiple objects need to share and extend the lifetime of a resource.

C++ small string optimization

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C++ small string optimization Small string optimization (SSO) is a technique where std::string stores short strings directly in its object rather than allocating from the heap. This eliminates heap allocation overhead for short strings (typically up to 15-24 bytes depending on the implementation) while keeping the

C++ static initialization order fiasco

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C++ static initialization order fiasco Static initialization order fiasco occurs when a static variable in one translation unit depends on a static variable in another, but their initialization order is undefined. If the dependency initializes first, it uses an uninitialized global, causing undefined behavior.

C++ strict aliasing

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C++ strict aliasing Strict aliasing is a rule stating that accessing an object through a pointer or reference of a different type (that doesn't form a proper subset relationship, like char*) causes undefined behavior. The compiler assumes pointers of different types never point to the same object and optimizes accordingly. Violating this assumption produces incorrect results.

C++ tag dispatch

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C++ tag dispatch Tag dispatch is a metaprogramming technique where overloaded functions are selected based on “tag” types (usually empty structs), enabling different behavior for different type categories at compile time. For example, passing std::random_access_iterator_tag

C++ type deduction

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C++ type deduction Type deduction is the process where the compiler infers template argument types from function arguments or variable initializers. Different deduction rules apply to different contexts: plain parameters deduce without references, reference parameters preserve reference-ness, and

C++ type erasure

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C++ type erasure Type erasure is a technique that allows storing and manipulating objects of different types through a common interface, typically using virtual functions or std::any. This hides the specific type from the container, trading compile-time type safety for runtime flexibility.

C++ undefined behavior

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C++ undefined behavior Undefined behavior occurs when a program violates C++ rules in a way the standard does not define. The compiler is free to do anything: crash, produce wrong results, or appear to work correctly sometimes. Common causes include out-of-bounds access, use-after-free, signed integer overflow, and data races.

C++ unique_ptr

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

C++ unique_ptr unique_ptr is an exclusive-ownership smart pointer that automatically deletes its managed object when destroyed. Only one unique_ptr can own an object at a time; ownership is transferred via move semantics, never copied. Use unique_ptr

C++ value categories

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C++ value categories Value categories classify expressions based on whether they can be used to obtain an object's address and whether they're about to be destroyed. Lvalues have persistent identity and can be referenced; rvalues (temporaries or results of

C++ virtual destructor

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C++ virtual destructor Virtual destructor is required in base classes meant for polymorphic use. When deleting a derived object through a base pointer, a non-virtual destructor calls only the base destructor, leaving derived cleanup code unrun and causing resource leaks.

C++ vtable

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

C++ vtable Vtable (virtual method table) is the compiler-generated table of function pointers used for virtual function dispatch. Each class with virtual functions has a vtable; each object holds a pointer (vptr) to its class's vtable. When a virtual function is called through a pointer or reference, the program looks up the function in the vtable.

C++ weak_ptr

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

C++ weak_ptr weak_ptr is a non-owning observer of an object managed by shared_ptr. It doesn't increment the reference count, so the object can be destroyed even if weak_ptrs exist. Use weak_ptr to break reference cycles and implement observer patterns without keeping objects alive.

CUDA atomics

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

CUDA atomics Atomics in CUDA are device functions that perform read-modify-write updates as one uninterruptible operation in either global or shared memory, making the operation indivisible when many threads update the same location. counter += 1; // race: thousands of threads, lost updates atomicAdd(&counter, 1); // correct

CUDA bank conflicts

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

CUDA bank conflicts Bank conflict happens when threads in a warp access different addresses that fall in the same shared memory bank, and the hardware serialises them. Shared memory is divided into 32 banks, each 4 bytes wide and interleaved so that consecutive 4-byte words land in consecutive banks.

CUDA coalescing

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

CUDA coalescing Coalescing is arranging accesses so that the 32 threads of a warp touch as few global memory sectors as possible and use all of what they pull in. Global memory is served in 32-byte sectors, not individual words, so unaligned or strided access patterns waste bandwidth.

CUDA constant memory

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

CUDA constant memory Constant memory is a small read-only region of device memory, declared with __constant__ and served through a dedicated cache. It is optimised for one specific pattern: every thread in a warp reading the same address at the same time.

CUDA error handling

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

CUDA error handling A kernel launch is asynchronous and returns no error code. Error handling in CUDA has to be explicit, and code that skips it fails silently: a kernel that never ran produces a program that exits with status 0 and wrong or absent output.

CUDA events

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

CUDA events Events are markers recorded in a stream that the device timestamps as it reaches them, solving the problem that timing a kernel with clock_gettime on the host gives the wrong answer because a launch is asynchronous and returns before the GPU has done anything.

CUDA examples

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

CUDA examples Working through a hello-world kernel to understand the async execution model, then a real-world SAXPY implementation for bandwidth measurement. Hello world walkthrough Compile and run the hello-world kernel from CUDA: $ nvcc -o hello hello.cu $ ./hello block 1 thread 0 block 1 thread 1 block 1 thread 2 block 1 thread 3 block 0 thread 0 block 0 thread 1 block 0 thread 2 block 0 thread 3 $y = \alpha x + y$

CUDA global memory

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

CUDA global memory Global memory is the GPU's main DRAM. It is what cudaMalloc returns, it is visible to every thread in every block, and it persists between kernel launches. It is also the slowest memory on the device, with latency in the range of 400 to 800 cycles.

CUDA kernels

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

CUDA kernels Kernel is a function that runs on the GPU, marked __global__ and called from host code with the <<<>>> launch syntax. It is executed once per thread by every thread in the grid you ask for. __global__ void scale(float *a, float k) { int i = blockIdx.x * blockDim.x + threadIdx.x; a[i] *= k; } scale<<<64, 256>>>(d_a, 2.0f); // 64 blocks x 256 threads = 16384 threads

CUDA memory model

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

CUDA memory model Memory model determines which threads can see a piece of data and how fast they can reach it, with several distinct memory spaces on a GPU each having very different sizes, speeds, and scopes. Choosing the right space is usually a bigger performance lever than anything done to the arithmetic.

CUDA memory transfer

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

CUDA memory transfer Memory transfer moves data between host and device across the PCIe bus and is often the real bottleneck in a GPU program. For small problems it costs more than the computation it feeds, since host and device have separate physical memory that must be explicitly moved.

CUDA occupancy

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

CUDA occupancy Occupancy is the ratio of warps resident on a multiprocessor to the maximum it can hold. It matters because resident warps are how the GPU hides memory latency: when one warp stalls on a load, another issues in its place. Too few warps and the multiprocessor sits idle.

CUDA overview

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

CUDA overview Quick reference for CUDA qualifiers, launch syntax, the runtime API, and tooling. Qualifiers and launch syntax __global__ void f(...) // kernel: called from host, runs on device __device__ int g(...) // device function: callable only from device code __host__ int h(...) // host function (the default) __shared__ float tile[256]; // per-block scratchpad, shared by threads in a block __constant__ float coeff[16]; // read-only, broadcast-optimis…

Backends and execution

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Backends and execution Backends are the execution targets: simulators (CPU, GPU) or real quantum hardware. CUDA-Q abstracts backends—same kernel code runs on any target. #include "cudaq.h" #include struct SimpleKernel { void operator()() __qpu__ { cudaq::qvector q(2); h(q[0]); cx(q[0], q[1]); mz(q); } }; int main() { // List available backends auto backends = cudaq::available_backends(); for (const auto& backend : backends) { printf("Available: %s\n", …

Integration with classical compute

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Integration with classical compute Classical integration allows seamless mixing of quantum and classical C++ code. Call quantum kernels from classical functions, process results, and feed back to quantum. #include "cudaq.h" #include #include #include // Quantum kernel struct QuantumPart { void operator()(std::vector angles) __qpu__ { cudaq::qvector q(angles.size()); for (size_t i = 0; i < angles.size(); i++) { ry(angles[i], q[i]); } …

Debugging and profiling

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Debugging and profiling Debugging quantum kernels involves printing intermediate results, validating against classical simulators, and profiling gate timing. #include "cudaq.h" #include struct DebugKernel { void operator()() __qpu__ { cudaq::qvector q(3); // Initialize h(q[0]); h(q[1]); h(q[2]); // Entangle cx(q[0], q[1]); cx(q[1], q[2]); // Measure mz(q[0], q[1], q[2]); } }; int main() { // Test on CPU simulator (slowe…

Distributed quantum simulation

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Distributed quantum simulation Distributed simulation spreads quantum state vectors across multiple GPUs or nodes, enabling simulation of even larger systems (30+ qubits). #include "cudaq.h" #include // Message Passing Interface struct LargeScaleCircuit { void operator()() __qpu__ { int n = 30; cudaq::qvector q(n); // Quantum operations for (int i = 0; i < n; i++) { h(q[i]); } for (int i = 0; i < n - 1; i += 2) { cx(q[i], q[i+1]); …

GPU acceleration with cuquantum

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

GPU acceleration with cuquantum GPU acceleration via NVIDIA's cuQuantum enables simulation of large quantum systems (20+ qubits) with high performance. The GPU backend exploits parallelism in state vector operations. #include "cudaq.h" // Large circuit: 25 qubits (requires GPU) struct LargeCircuit { void operator()() __qpu__ { int n = 25; cudaq::qvector q(n); // Hadamard layer: O(n) gates for (int i = 0; i < n; i++) { h(q[i]); } // Entangling layer: …

Gradient computation and optimization

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Gradient computation and optimization Gradient computation enables efficient parameter optimization for variational algorithms. CUDA-Q supports parameter shift rule and automatic differentiation. #include "cudaq.h" #include "cudaq/gradients.h" #include "cudaq/optimizer.h" #include struct ParameterizedAnsatz { void operator()(std::vector params) __qpu__ { cudaq::qvector q(2); ry(params[0], q[0]); ry(params[1], q[1]); cx(q[0], q[1]); rz(params[2], q[0]); …

Hardware integration and qpus

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Hardware integration and qpus Hardware integration allows targeting real quantum processors (IonQ, IQM, etc.) via CUDA-Q's backend abstraction. Same kernel code runs on simulators or hardware with minimal changes. #include "cudaq.h" #include // Hardware-agnostic kernel struct HardwareKernel { void operator()() __qpu__ { cudaq::qvector q(5); // Standard gates (available on most QPUs) for (int i = 0; i < 5; i++) { h(q[i]); } // CNOT chain (common …

Hybrid quantum-classical Computing

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Hybrid quantum-classical Computing Hybrid quantum-classical computing interleaves quantum operations with classical computation. Classical code drives quantum kernels, processes results, and makes decisions—all in the same program. This is essential for variational algorithms, error mitigation, and real-time feedback.

Measurement and readout

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Measurement and readout Measurement collapses qubits to classical bits. In CUDA-Q, use mz(qubit) (measure in Z basis) to get bitstrings. Collect many shots to build probability distributions. #include "cudaq.h" // Measure specific qubits struct SelectiveMeasure { void operator()() __qpu__ { cudaq::qvector q(3); h(q[0]); cx(q[0], q[1]); mz(q[0]); // Measure qubit 0 only mz(q[1], q[2]); // Measure qubits 1, 2 } }; // Measure all qubits struct MeasureAll { v…

Noise models and open system simulation

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Noise models and open system simulation Noise models simulate realistic hardware imperfections: depolarizing errors, dephasing, amplitude damping. CUDA-Q integrates with QuTiP for open system simulation. #include "cudaq.h" #include "cudaq/noise_model.h" // Define noise model struct NoiseKernel { void operator()() __qpu__ { cudaq::qvector q(2); h(q[0]); cx(q[0], q[1]); mz(q); } }; int main() { // Create depolarizing noise model cudaq::noise_model noise_model; // …

Optimization in CUDA-q

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

Optimization in CUDA-q Optimization finds parameters that minimize a cost function. CUDA-Q provides built-in optimizers (COBYLA, Adam, SLSQP) and integrates gradients for efficient training. #include "cudaq.h" #include "cudaq/optimizer.h" #include "cudaq/gradients.h" #include #include struct CostCircuit { void operator()(std::vector params) __qpu__ { cudaq::qvector q(2); ry(params[0], q[0]); ry(params[1], q[1]); cx(q[0], q[1]); rz(params[2], q[0…

Parameterized quantum circuits

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Parameterized quantum circuits Parameterized circuits accept classical parameters (angles, coupling strengths) and use them in gate operations. Essential for variational algorithms where you optimize parameters. #include "cudaq.h" #include // Single parameter struct SingleParam { void operator()(double theta) __qpu__ { cudaq::qvector q(1); ry(theta, q[0]); mz(q[0]); } }; // Multiple parameters struct MultiParam { void operator()(std::vector params) __qpu__…

Performance optimization

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Performance optimization Performance optimization for quantum kernels involves minimizing gate count, leveraging GPU acceleration, and efficient batching. #include "cudaq.h" #include #include // Naive kernel: many redundant operations struct NaiveKernel { void operator()(int n) __qpu__ { cudaq::qvector q(n); // Redundant: h then x then h = not much for (int i = 0; i < n; i++) { h(q[i]); x(q[i]); h(q[i]); } mz(q); } }; // …

CUDA-Q programming model

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

CUDA-Q programming model CUDA-Q follows a kernel-based model similar to CUDA: you write quantum kernels (__qpu__ functions), compile them, then invoke them from classical host code. The runtime handles scheduling, execution, and result collection. Execution model

QAOA (quantum approximate optimization algorithm)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

QAOA (quantum approximate optimization algorithm) QAOA solves combinatorial optimization problems via alternating cost and mixer Hamiltonians. The ansatz is a parameterized circuit; optimize parameters to maximize objective. #include "cudaq.h" #include "cudaq/algorithm/QAOA.h" #include "cudaq/optimizer.h" // Cost Hamiltonian: encodes problem (e.g., MaxCut) // For MaxCut on edge (0,1): H_C = 0.5*(Z_0*Z_1 - 1) cudaq::spin_op cost_hamiltonian = 0.5 * (cudaq::spin::z(0) * cudaq::spin::z(1) - …

Quantum algorithms library

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

Quantum algorithms library CUDA-Q provides a standard library of quantum algorithms: VQE, QAOA, Grover's, phase estimation, and others. These are implemented as reusable C++ templates. #include "cudaq.h" #include "cudaq/algorithm/VQE.h" #include "cudaq/algorithm/QAOA.h" // VQE: find ground state of a Hamiltonian struct SimpleHamiltonian { void operator()(std::vector params) __qpu__ { cudaq::qvector q(2); ry(params[0], q[0]); ry(params[1], q[1]); cx(q[0], q[1]); …

Quantum kernels

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Quantum kernels Quantum kernels are C++ functions marked __qpu__ that contain quantum operations. They're compiled to quantum instructions and executed on quantum backends. Kernels can take classical parameters and return measurement results. #include "cudaq.h" // Simple kernel: no parameters struct BellState { void operator()() __qpu__ { cudaq::qvector q(2); h(q[0]); cx(q[0], q[1]); mz(q); // Measure both qubits } }; // Parameterized kernel struct RYGate { void opera…

Quantum machine learning

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Quantum machine learning Quantum machine learning (QML) uses quantum circuits as neural networks trained on classical data. CUDA-Q integrates with ML frameworks for end-to-end training. #include "cudaq.h" #include "cudaq/gradients.h" #include #include // Quantum layer: parameterized circuit struct QuantumLayer { void operator()(std::vector params) __qpu__ { int n = params.size(); cudaq::qvector q(n); // Encoding layer: encode classical data as rota…

State preparation

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

State preparation State preparation initializes qubits to desired quantum states. All qubits start in $|0\rangle$; use gates to prepare superpositions, entangled states, or arbitrary states. #include "cudaq.h" #include // Prepare equal superposition struct EqualSuperposition { void operator()(int n_qubits) __qpu__ { cudaq::qvector q(n_qubits); for (int i = 0; i < n_qubits; i++) { h(q[i]); // Hadamard: |0⟩ → (|0⟩ + |1⟩)/√2 } mz(q); } }; // Prepare Bell stat…

VQE (variational quantum eigensolver)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

VQE (variational quantum eigensolver) VQE finds ground state energies of Hamiltonians using a variational ansatz trained by a classical optimizer. Given Hamiltonian $H$, VQE finds parameters $\theta^*$ that minimize $\langle \psi(\theta) | H | \psi(\theta) \rangle$. #include "cudaq.h" #include "cudaq/algorithm/VQE.h" #include "cudaq/optimizer.h" #include // Hamiltonian: combination of Pauli operators // H = 0.5*Z + 0.25*X cudaq::spin_op hamiltonian = 0.5 * cudaq::spin::z(0) + …

CUDA-Q

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

CUDA-Q CUDA-Q is NVIDIA's open-source quantum computing platform for hybrid quantum-classical computing in C++. Define quantum kernels as C++ functions, execute on quantum simulators (GPU-accelerated via cuQuantum) or real quantum hardware; integrate with classical compute and ML. CUDA-Q abstracts backend details, letting you write once and target different quantum processors.

CUDA reduction

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

CUDA reduction Reduction in CUDA has no direct equivalent of OpenMP's reduction clause and is written by hand as a tree: each block reduces its own slice in shared memory, then the partial results are combined. Summing an array on a GPU therefore requires careful coordination across blocks.

CUDA shared memory

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

CUDA shared memory Shared memory is a small, fast scratchpad private to each thread block, declared with __shared__. It sits on the multiprocessor itself, roughly an order of magnitude faster than global memory, and it is the main tool for cutting memory traffic when threads reuse the same data.

CUDA streams

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

CUDA streams Stream is an ordered queue of device work where operations in the same stream run in order while operations in different streams may run concurrently. Everything goes into the default stream unless told otherwise, which is why a naive program serialises transfers and kernels that could have overlapped.

CUDA synchronization

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

CUDA synchronization Synchronization in CUDA exists at three levels with different scopes: within a block (e.g. __syncthreads(), a barrier across all threads), within a warp, and between the host and the device. __shared__ float tile[256]; tile[threadIdx.x] = in[i]; __syncthreads(); // every thread has written before any thread reads float left = tile[threadIdx.x - 1];

CUDA tensor cores

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

CUDA tensor cores Tensor cores are dedicated units that compute a small matrix multiply-accumulate in one instruction, $D = A \times B + C$, on tiles of roughly 16×16. Introduced with the Volta architecture, they exist because dense matrix multiplication dominates deep learning and much of scientific computing, and a specialised unit does it far faster than the general-purpose lanes.

CUDA thread hierarchy

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

CUDA thread hierarchy Thread hierarchy organises threads in two levels: a launch creates a grid of blocks, and each block holds up to 1024 threads. Every kernel uses this hierarchy to work out which element it is responsible for. int i = blockIdx.x * blockDim.x + threadIdx.x;

CUDA unified memory

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

CUDA unified memory Unified memory is a single allocation addressable from both the host and the device, created with cudaMallocManaged. The driver migrates pages between CPU and GPU on demand, so the explicit cudaMemcpy pairs disappear. float *a; cudaMallocManaged(&a, n * sizeof(float)); for (int i = 0; i < n; i++) a[i] = 1.0f; // touched on the host kernel<<>>(a, n); // pages migrate to the device cudaDeviceSynchronize(); // required before r…

CUDA warp divergence

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

CUDA warp divergence Warp divergence happens when threads in the same warp take different branches and the hardware has to run both sides one after the other, masking off the threads that are not on the current path. Since all 32 threads share one instruction stream, this serialisation kills performance.

CUDA warps

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

CUDA warps Warp is a group of 32 threads that execute together in lockstep and is the real unit of scheduling on NVIDIA hardware. Blocks are a programming convenience, but the hardware splits every block into warps and issues instructions one warp at a time.

CUDA

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

CUDA CUDA is NVIDIA's platform for running general-purpose code on GPUs. You write a function called a kernel, and the GPU runs it in thousands of threads at once. It consists of a language extension to C and C++ (compiled with nvcc), a runtime library, and a driver. Where

cuDensityMat

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:37:48+00:00

cuDensityMat cuDensityMat is NVIDIA's GPU library for open quantum system simulation via density matrices and Lindblad superoperators. Supports Pauli operators, Lindblad jump operators, CPTP maps, and master equation dynamics. Essential for decoherence simulation and quantum error correction studies. Part of cuQuantum ecosystem.

cuQuantum

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:37:38+00:00

cuQuantum cuQuantum is NVIDIA's GPU library suite for quantum circuit simulation: cuStateVec (state vector/density matrix, ~30 qubits per GPU) and cuTensorNet (tensor network contraction with automatic path optimization). Powers variational algorithms, benchmarking, and large-scale hybrid workflows. Used by vendor frameworks and research projects.

cuStateVec

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:37:41+00:00

cuStateVec cuStateVec is NVIDIA's low-level GPU library for quantum state vector and density matrix simulation. Optimized kernels for gates, measurements, and observables support ~30 qubits per GPU. Used as backend in higher-level frameworks (CUDA-Q, cuQuantum, Qiskit). Suitable for custom simulators and HPC integration.

cuTensorNet

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:37:45+00:00

cuTensorNet cuTensorNet is NVIDIA's GPU library for tensor network contraction. Automatically optimizes contraction paths and executes with GPU kernels. For quantum circuits represented as tensor networks, enables simulation of larger systems than state vectors by exploiting structure and sparsity. Complements cuStateVec for circuits with shallow entanglement or many qubits.

CX gate (CNOT)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

CX gate (CNOT) CX gate (controlled-X, also called CNOT or controlled-NOT) is a two-qubit gate that flips the target qubit if and only if the control qubit is $\lvert 1\rangle$, and does nothing otherwise. It is the standard entangling gate in quantum computing. $$\text{CX} = \begin{pmatrix}1 & 0 & 0 & 0\\ 0 & 1 & 0 & 0\\ 0 & 0 & 0 & 1\\ 0 & 0 & 1 & 0\end{pmatrix}$$ The rows and columns are ordered $\lvert 00\rangle, \lvert 01\rangle, \lvert 10\rangle, \lvert 11\rangle$$$\text{CX}\lvert 00\ran…

CY gate

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

CY gate CY gate (controlled-Y) is a two-qubit gate that applies a Pauli Y to the target qubit if and only if the control qubit is $\lvert 1\rangle$, and does nothing otherwise. $$\text{CY} = \begin{pmatrix}1 & 0 & 0 & 0\\ 0 & 1 & 0 & 0\\ 0 & 0 & 0 & -i\\ 0 & 0 & i & 0\end{pmatrix}$$ The rows and columns are ordered $\lvert 00\rangle, \lvert 01\rangle, \lvert 10\rangle, \lvert 11\rangle$, with the first qubit as control and the second as target: $$\text{CY}\lvert 00\rangle = \lvert 00\rangle \…

CZ gate

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

CZ gate CZ gate (controlled-Z) is a two-qubit gate that applies a Pauli Z to the target qubit if and only if the control qubit is $\lvert 1\rangle$, and does nothing otherwise. Because Z only adds a phase of $-1$ to $\lvert 1\rangle$, the gate is symmetric: either qubit can be treated as the control.$$\text{CZ} = \begin{pmatrix}1 & 0 & 0 & 0\\ 0 & 1 & 0 & 0\\ 0 & 0 & 1 & 0\\ 0 & 0 & 0 & -1\end{pmatrix}$$$\lvert 00\rangle, \lvert 01\rangle, \lvert 10\rangle, \lvert 11\rangle$$\lvert 11\rangle$$$…

D-Wave

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

D-Wave D-Wave is a Canadian company and one of the earliest commercial quantum vendors. It builds superconducting qubits related to Transmon qubits, but wires them for quantum annealing instead of gate-model circuits like IBM quantum and Google quantum AI run. Qubits are coupled to represent an optimization problem as an energy landscape, then slowly evolved so they settle into a low-energy state that approximates the answer.

Dagger compact category

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:37:19+00:00

Dagger compact category Dagger compact category combines compact categories (formalizing quantum systems with bra-ket structure) with a dagger operation (adjoint/time-reversal). Encodes unitarity, reversibility, and measurement. The semantic foundation for categorical quantum mechanics; enables diagrammatic proofs of quantum protocol correctness.

Debian building packages

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

Debian building packages Debian packages (.deb) are the standard distribution format. Building custom packages requires source and metadata. Package components A source package consists of three files: * .orig.tar.gz: original upstream source *

Debian configuration files

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

Debian configuration files Most system configuration lives in /etc. Understanding common formats and safety practices is essential. File locations * /etc/: system config * ~/.config/: per-user config (modern apps) * ~/.bashrc, ~/.profile: shell config

Debian development tools

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

Debian development tools Debian provides compilers, interpreters, debuggers, and version control for software development. Build essentials Install compiler, linker, make, and headers: sudo apt install build-essential This pulls in gcc, g++, make

Debian disk and filesystems

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

Debian disk and filesystems Manage storage: partitions, formatting, mounting, and monitoring disk usage. Listing disks and partitions lsblk lsblk -f # show filesystems Show device details: fdisk -l parted -l Partitioning Interactive partition editor:

Debian filesystem

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

Debian filesystem Debian follows the Filesystem Hierarchy Standard (FHS), a standard layout for Linux filesystems. Understanding the directory structure helps you find files, configure systems, and write portable scripts. Key directories: * /bin,

Debian kernel and modules

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

Debian kernel and modules The kernel is Debian's core OS. Modules are pluggable drivers and features. Kernel info Show running kernel version: uname -r uname -a # verbose Check available kernel images: dpkg -l | grep linux-image Kernel upgrade

Debian locale and timezone

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

Debian locale and timezone Configure language, character encoding, and time settings for your system. Timezone Show current timezone: timedatectl List available timezones: timedatectl list-timezones timedatectl list-timezones | grep America

Debian logging

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

Debian logging Debian logs system events, service messages, and errors to help troubleshoot issues. systemd journal Primary log interface (all systemd-managed services): journalctl Follow logs in real-time: journalctl -f Last 50 lines: journalctl -n 50

Debian networking

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

Debian networking Configure and troubleshoot network interfaces, routing, and DNS on Debian. Network interfaces Show interfaces and addresses: ip addr show ip addr show eth0 Bring interface up/down: sudo ip link set eth0 up sudo ip link set eth0 down

Debian package manager

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

Debian package manager apt (Advanced Package Tool) is the standard Debian/Ubuntu package manager. It manages .deb files and their dependencies. Basic commands Update package lists from repositories: sudo apt update Install a package: sudo apt install package-name

Debian permissions

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

Debian permissions File permissions control who can read, write, and execute. Three types: owner (user), group, others. Each has three permissions: read (r=4), write (w=2), execute (x=1). Octal notation Permissions are summed: rwx = 4+2+1 = 7. Set with

Debian processes

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

Debian processes A process is a running instance of a program. Each has a unique process ID (PID), parent process ID (PPID), and runs as a specific user. Listing processes List all processes: ps aux Output: USER, PID, CPU%, MEM%, VSZ, RSS, TTY, STAT, START, TIME, COMMAND

Debian release cycle

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

Debian release cycle Debian has multiple releases at different maturity levels: Stable, Testing, and Unstable. Release names * Stable (current): thoroughly tested, conservative updates, security fixes for ~5 years * Testing (next): receives new package versions daily, tested less, becomes stable every 2 years

Debian repositories

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

Debian repositories Repositories are remote servers that host packages. Debian pulls from multiple sources configured in /etc/apt/sources.list and /etc/apt/sources.list.d/. Sources list format deb http://deb.debian.org/debian bookworm main contrib non-free-firmware deb http://security.debian.org/debian-security bookworm-security main contrib non-free-firmware

Debian scheduling

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

Debian scheduling Run tasks at specific times or intervals using cron or at. Cron Most common scheduler. Edit user crontab: crontab -e Edit root crontab: sudo crontab -e List your crons: crontab -l Cron format minute hour day month day-of-week command 0 2 * * * /path/to/backup.sh

Debian services and systemd

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

Debian services and systemd systemd is the service manager. It starts, stops, and manages daemons (background processes). Services are defined as unit files. Basic commands Start a service: sudo systemctl start ssh Stop: sudo systemctl stop ssh

Debian shell and environment

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

Debian shell and environment Bash is the default shell on Debian. When you log in, bash reads /etc/profile (system-wide) and ~/.bashrc (user-specific) to set up your environment. Add commands and variables to ~/.bashrc to customize your shell. $ echo $SHELL # current shell $ chsh -s /bin/bash # change default shell (on next login) $ cat ~/.bashrc # view bash configuration $ source ~/.bashrc # reload configuration

Debian SSH

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

Debian SSH SSH (Secure Shell) allows remote command execution and file transfer over encrypted connections. Basic connection Connect to remote host: ssh user@host ssh user@host -p 2222 # non-standard port Run single command (no interactive shell):

Debian text editors

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

Debian text editors Debian provides several text editors with different learning curves and capabilities. nano Beginner-friendly, simple modal editor. Starts in edit mode: nano file.txt Common commands (Ctrl prefix): * Ctrl+X: exit * Ctrl+O

Debian users and groups

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

Debian users and groups Every process on Debian runs as a user. Users have numeric identifiers (UIDs), groups have GIDs. Permissions and resource limits are assigned per-user and per-group. Adding users Create a user with a home directory: useradd -m username

Debian gnu/linux

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

Debian gnu/linux Debian GNU/Linux is a free, stable operating system built and maintained by volunteers. It emphasizes stability, reliability, and open-source principles. Debian is the foundation for many Linux distributions (Ubuntu, Linux Mint, Proxmox, etc.) and runs everywhere from embedded systems to supercomputers.

Density matrix

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

Density matrix Density matrix (written as $\rho$) is a matrix representation of a quantum state. It's a more general way to represent a quantum state compared to 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\rangl…

Deutsch-Jozsa

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

Deutsch-Jozsa 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's algorithm to $n$-bit inputs.$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…

Deutsch

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

Deutsch Deutsch'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\rangle\lvert …

Dirac notation

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

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{ket}\rangle$ and bras are written as $\langle\text{bra}\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\en…

Docker building images

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Docker building images Building creates an image from a Dockerfile. Run docker build -t . to build from the Dockerfile in the current directory. The . is the build context: the files Docker has access to for COPY instructions. Keep large files out of it using

Docker compose

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Docker compose Compose defines multi-container applications in docker-compose.yml. Services are containers; each service uses an image and configuration. docker compose up starts all services; docker compose down stops and removes them. Compose creates a shared network so services reach each other by service name.

Docker containers

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Docker containers Containers are running instances of images, with isolated filesystems, networks, and environment. Start a container with docker run; it boots instantly and includes all dependencies. Containers are ephemeral by default—data and changes disappear when they stop, unless you use volumes.

Docker dockerfile

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Docker dockerfile Dockerfile is a text file listing instructions to build an image. Start with a base image (e.g., FROM ubuntu:22.04), then layer changes on top with RUN, COPY, WORKDIR, ENV, etc. Docker builds the image by executing each instruction sequentially, creating a new layer for each step.

Docker entrypoint and CMD

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Docker entrypoint and CMD ENTRYPOINT is the command that runs when a container starts. CMD provides default arguments. The Dockerfile CMD is overridden by arguments to docker run. Use ENTRYPOINT for the main command and CMD for common default arguments. Both can be exec form (JSON array) or shell form (string).

Docker environment variables

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Docker environment variables Environment variables configure containers at runtime. Set them in the Dockerfile with ENV or at runtime with docker run -e. Use .env files with docker compose env_file. Containers inherit the environment from their base image plus any added with ENV or

Docker images

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Docker images Images are blueprints for containers: layered filesystem snapshots plus metadata. Run docker run to start a container from an image; it starts instantly with everything pre-configured. Images are pulled from registries like Docker Hub and stored locally for reuse.

Docker layers

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Docker layers Layers are stacked filesystem snapshots. Each Dockerfile instruction creates a layer; the image is the union of all layers. Layers are cached—rebuilding reuses unchanged layers, making subsequent builds fast. Inspect layers with docker history

Docker networks

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Docker networks Networks allow containers to communicate. By default, containers on the same network can reach each other by service name. Create custom networks for isolation; bridge networks are best for most use cases. Compose automatically creates a shared network for all services.

Docker ports

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Docker ports Port mapping connects container ports to host ports. Use docker run -p : to map. Multiple -p flags map multiple ports. EXPOSE is a Dockerfile instruction that documents ports but doesn't actually publish them. Containers on the same network reach each other by name without explicit port mapping.

Docker pulling and pushing

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Docker pulling and pushing Pulling fetches images from a registry to your local machine. Pushing sends local images to a registry. Before pushing, tag the image with the registry hostname. Authentication is required for private registries via docker login

Docker registries

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Docker registries Registries store and distribute images. Docker Hub is the public default registry; you pull images from it without specifying a registry hostname. Push with docker push and pull with docker pull. Private registries require authentication via

Docker running containers

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Docker running containers Running a container starts an instance from an image. Use docker run to start; add -it for interactive (attach a terminal), -d to run in background, --name to give it a name. The container stops when its main process exits.

Docker tagging

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Docker tagging Tags identify image versions. An image name is /:; the latest tag is the default. Retag an image with docker tag to give it multiple names (e.g., myapp:1.0 and myapp:latest both point to the same layers). Tags are just pointers, not versions—retagging the same tag name overwrites it.

Docker volumes

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Docker volumes Volumes persist data beyond container lifetime. By default, containers are ephemeral—data disappears when they stop. A bind mount maps a host directory into the container. A named volume lets Docker manage storage; you refer to it by name and can mount it into multiple containers.

Docker

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

Docker Docker is a containerization platform that packages your application and its dependencies into a lightweight, portable unit called a container. Run docker run to start a container from an image; it starts instantly and includes everything your app needs—no

Dragon

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

Dragon Dragon is a snoopy cache coherence protocol from Xerox PARC that uses update-based invalidation instead of invalidation: writes broadcast new values on the bus and sharers update their copies in place rather than discarding them. This favors workloads where shared lines are read frequently after writes.

Dynamic array

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

Dynamic array A dynamic array is a resizable sequence backed by a heap-allocated Array. It provides O(1) indexed access like a fixed array, but grows automatically when capacity is exceeded. When the backing array is full and a new element is appended, the implementation allocates a larger array (typically 2×), copies all elements over, and frees the old allocation. The amortised cost of appending is O(1) because the copying work is spread across all the inserts that preceded the resize.

Eigenstate

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

Eigenstate Eigenstate is refers to a quantum state associated with a quantum gate that remains unchanged after applying the gate.

Embarrassingly parallel

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

Embarrassingly parallel Embarrassingly parallel describes a problem that can be split into independent pieces with no communication or synchronization between them. Each piece runs on its own core, thread, or machine, and results are collected at the end. The name reflects that there's nothing clever about the parallelization—the difficulty of real parallel problems (data dependencies, load balancing, synchronization) is absent.

Embedded engineering

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

Embedded engineering Embedded engineering is the discipline of writing software for microcontrollers (MCUs) and other resource-constrained hardware that is dedicated to a single task or a fixed set of tasks. Unlike general-purpose computing, an embedded system usually has no operating system, no display, and no user interacting with it directly — it just runs, often for years without being rebooted, inside some larger device.

EOF

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

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's when you want to supply a multiline text to a command to its standard output, using

(WIP) equations of electromagnetism

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

(WIP) equations of electromagnetism Electrostatics Coulomb's law Attractive force $Q_2$ feels thanks to $Q_1$'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…

False sharing

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

False sharing False sharing is a performance bug where two threads modify logically unrelated variables that fall on the same cache line, causing the coherence protocol to bounce the line back and forth between cores as if they were contending for the same data. Nothing is functionally wrong—each thread only touches its own variable—but cache-line granularity creates artificial contention.

FFT

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

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.

Firefly

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

Firefly Firefly is an update-based snoopy cache coherence protocol from DEC's Systems Research Center that uses a dedicated “shared wire” on the bus to signal whether a loaded line is exclusively held or shared. This lets caches determine exclusivity at load time, avoiding ambiguity on the first write similar to MESI's Exclusive state.

FLOPS

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

FLOPS FLOPS (Floating-Point Operations Per Second) measures the rate at which a processor performs floating-point arithmetic, and is the standard unit for comparing raw compute throughput in HPC. Peak FLOPS is the theoretical maximum based on hardware specs; achieved FLOPS on real code is almost always lower due to memory stalls, branches, and non-arithmetic instructions.

Fluxonium qubits

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

Fluxonium qubits Fluxonium qubits are superconducting qubits that add a large inductance, usually implemented as an array of Josephson junctions, in parallel with a single small junction and a capacitor. This extra inductive shunt suppresses charge noise sensitivity even further than the transmon and, more importantly, gives the qubit a much larger anharmonicity. The tradeoff is a more complex fabrication process, since the inductive shunt typically needs tens to hundreds of junctions in series…

Fork-join model

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

Fork-join model Fork-join model structures parallel execution as phases: a single thread forks into multiple threads that run concurrently, then join back into one before proceeding. It underlies OpenMP's #pragma omp parallel, Cilk, and many task-parallel runtimes. The join point is an implicit barrier—no thread proceeds until all forked threads finish and their writes become visible.

Forward list

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

Forward list A forward list is a singly linked list with a single pointer to the head and no tail pointer. Each node holds a value and a next pointer; there is no prev. Traversal is one-directional: from head toward NULL. It is the minimal linked sequence — less memory per node than a

GCC assembly

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:01:52+00:00

GCC assembly Reading generated assembly is the ground truth when debugging performance—it shows exactly what the CPU will execute. Use -S to generate assembly, and -fverbose-asm to annotate it with source variable names. gcc -O3 -march=native -S -fverbose-asm hot_loop.c -o hot_loop.s cat hot_loop.s

GCC basics

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

GCC basics GCC is the GNU Compiler Collection—the default C, C++, and Fortran compiler on most Linux systems. Install it via your package manager along with build tools. sudo apt install build-essential # Debian/Ubuntu sudo dnf groupinstall "Development Tools" # Fedora/RHEL

GCC cross-compilation

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

GCC cross-compilation Cross-compilation produces binaries for a different architecture than the build machine. Useful for embedded systems, bare-metal firmware, and HPC clusters with different CPU architectures. # Build on x86, produce ARM binary arm-linux-gnueabihf-gcc -o app app.c # Build on x86, produce risc-v binary riscv64-linux-gnu-gcc -o app app.c

GCC debugging

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

GCC debugging Debug symbols (-g flag) embed source file names, line numbers, and variable information into the binary. GDB uses these to map machine instructions back to source code. gcc -g -o app app.c # include debug symbols gcc -g -O0 -o app app.c # debug build (no optimization) gcc -g -O3 -o app app.c # optimized with debug symbols (can work)

GCC flags reference

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

GCC flags reference Optimization flags: -O0, -O1, -O2, -O3 optimization level (0=none, 3=aggressive) -Os optimize for code size -Ofast aggressive, may violate language semantics -fprofile-generate instrument for profiling -fprofile-use optimize using profiling data -fopt-info-vec report vectorization details -flto link-time optimization -fno-inline disable function inlining

GCC inlining

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

GCC inlining Function inlining replaces a function call with its body, eliminating call overhead and enabling better optimization across the boundary. GCC inlines automatically at -O2 and above, but you can guide it with hints and flags. gcc -O3 -o app app.c # automatic inlining gcc -O3 -finline-functions -o app app.c # aggressive inlining

GCC link-time optimization

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

GCC link-time optimization Link-time optimization (LTO) (-flto) defers optimization until link time, when the compiler has the entire program visible. This enables optimizations across translation units—inlining functions from other files, eliminating unused code globally, and whole-program analysis.

GCC optimization levels

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

GCC optimization levels Optimization levels (-O0 through -O3, -Os, -Ofast) enable bundles of passes that transform code. Each level adds more aggressive optimizations, trading compilation time and code size for runtime speed. -O0 (default) disables optimization entirely. Code compiles instantly but runs slowly and produces predictable output for debugging. Essential for

GCC performance tuning

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

GCC performance tuning Performance optimization is iterative: measure, identify bottlenecks, apply targeted optimizations, measure again. Start with compiler flags, then optimize code if needed. Baseline: Compile with standard flags and benchmark:

GCC profiling

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

GCC profiling GCC profiling with -pg instruments the program to record function call counts and execution time. Use gprof to analyze the results. This is a simple, portable alternative to perf but less detailed. gcc -pg -O3 -o app app.c ./app # runs normally but creates gmon.out gprof app gmon.out # analyze profiling data

GCC vectorization

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

GCC vectorization Vectorization enables GCC to use SIMD (Single Instruction Multiple Data) instructions—AVX2, AVX-512, NEON, etc.—to process multiple data elements in parallel. A loop that processes one array element per iteration can be transformed to process 4-8 elements simultaneously, massively increasing throughput.

GCC warnings

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

GCC warnings Compiler warnings catch bugs at compile time—uninitialized variables, type mismatches, unused code, unreachable statements. Treating warnings as bugs forces you to write cleaner code. gcc -Wall -Wextra -Wpedantic -o app app.c -Wall

GCC

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

GCC GCC (GNU Compiler Collection) is the standard C, C++, and Fortran compiler on Linux. More than a translator to machine code—it optimizes aggressively, reordering instructions, eliminating dead code, vectorizing loops, and inlining functions. Performance can change by an order of magnitude based on optimization choices.

GDB advanced features

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

GDB advanced features GDB supports Python scripting, remote debugging, and signal handling. These features enable automation, distributed debugging, and fine-grained control over program behavior. Python scripting GDB allows Python scripts to inspect and control programs. Define custom commands or automate debugging tasks:

GDB basics

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

GDB basics GDB (GNU Debugger) inspects and controls running programs. Start with the binary as an argument: gdb ./program. Compile with -O0 -g for reliable debugging (no optimization, keep debug symbols). $ gcc -O0 -g -o app app.c # compile with debug symbols $ gdb ./app # start GDB $ gdb --args ./app arg1 arg2 # pass arguments to program $ gdb -p PID # attach to running process

GDB breakpoints

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

GDB breakpoints Breakpoints pause execution so you can inspect state. Set at a line, function, or condition. (gdb) break main # breakpoint at function 'main' (gdb) break file.c:10 # breakpoint at line 10 in file.c (gdb) break file.c:10 if x > 5 # conditional: pause only if x > 5 (gdb) info breakpoints # list all breakpoints (gdb) delete 1 # delete breakpoint 1 (gdb) disable 1 # disable (don't stop, keep it) (gdb) enab…

GDB call stack

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

GDB call stack The call stack is the chain of function calls that led to the current execution point. Navigating it helps you understand how you reached an error and inspect variables in each caller. (gdb) backtrace # show all stack frames (gdb) backtrace 10 # show last 10 frames (gdb) frame 0 # select innermost frame (current function) (gdb) frame 3 # select frame 3 (third caller up) (gdb) up # move to ca…

GDB commands

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

GDB commands GDB commands control execution and inspection. Most commands have short abbreviations. Typing a blank line repeats the last command. run (r) start program continue (c) resume from breakpoint next (n) next line (skip calls) step (s) next line (step into calls) finish run until return until line run until line reached break (b) location set breakpoint watch variable set watchpoint print (p)…

GDB configuration

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

GDB configuration GDB init file (~/.gdbinit) auto-loads on startup. Use it to set options, define commands, and configure debugging defaults. # ~/.gdbinit set print pretty on # pretty-print structures set pagination off # no paging (useful for scripts) set print address off # hide memory addresses in output set confirm off # no confirmation prompts set history save on # save command history set history size 10000 # …

GDB debugging crashes

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

GDB debugging crashes Core dumps capture the program's memory at the moment of a crash. Load a core dump in GDB to inspect the crash stack and variables without attaching beforehand or re-running the program. ulimit -c unlimited # enable core dumps (bash/zsh) ./program # crash produces core.PID in current dir gdb ./program core.1234 # load crash into GDB (gdb) backtrace # show stack at crash (gdb) frame 0 # inspe…

GDB examining state

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

GDB examining state Printing variables and state tells you what values the program holds. Print can show variables, expressions, array contents, and dereferenced pointers. (gdb) print x # show value of x (gdb) print x + y # show expression (gdb) print arr # show array (often prints just base address) (gdb) print arr[0] # show first element (gdb) print *ptr # dereference pointer (gdb) print &variable # addr…

GDB inspecting memory

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

GDB inspecting memory Memory inspection dumps raw bytes at addresses. The x command (examine) shows bytes in various formats. Useful for inspecting memory layout, stack contents, or raw pointer data. (gdb) x/10x &variable # show 10 hex values at address of variable (gdb) x/10i $pc # show 10 instructions at program counter (gdb) x/20x $sp # show 20 hex words on stack (gdb) x/s ptr # print string at pointer (gdb) x/d &x …

GDB running and stepping

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

GDB running and stepping Execution control moves through code to find where things break. Run starts the program; stepping commands move line-by-line with different depth. (gdb) run # start program (pauses at breakpoint) (gdb) run arg1 arg2 # start with command-line arguments (gdb) run < input.txt # redirect stdin (gdb) continue (c) # resume from breakpoint (gdb) next (n) # next line (skip into function calls) (gdb) ste…

GDB TUI (text user interface)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

GDB TUI (text user interface) GDB TUI is a visual interface showing source code and a command window side-by-side. Useful for seeing code context while stepping, but slower than command-line. gdb -tui ./program # start GDB with TUI enabled # or in GDB: (gdb) tui enable # toggle TUI on (gdb) Ctrl+X, A # toggle TUI (keyboard shortcut)

GDB watching expressions

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

GDB watching expressions Watches pause execution when a variable changes value. Displays auto-print a value every time execution pauses. Together they monitor state without repeatedly typing print commands. (gdb) watch x # pause when x changes (gdb) watch arr[5] # pause when arr[5] changes (gdb) watch *ptr # pause when dereferenced pointer changes (gdb) info breakpoints # list watches (shown as "watchpoint") (gdb) delete 1 …

GDB

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

GDB GDB (the GNU Debugger) lets you inspect and control a running program: pause execution at any line, examine variables, walk the call stack, and step through code. It works on C, C++, Fortran, and other compiled languages by reading debug symbols embedded during compilation.

General writing guide

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

General writing guide General writing guide (this article) is a guide to writing articles in this wiki. Audience The intended audience is someone technically inclined — comfortable reading code and following a logical argument, but not necessarily with a formal background in every subject the wiki covers. Two things to keep in mind while writing:$\alpha$$e^{i\theta}$$H^\dagger = H$$$X = \begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix}$$

GFLOPS

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

GFLOPS GFLOPS is FLOPS measured in units of $10^9$ (gigaflops) floating-point operations per second, the natural scale for a single CPU core. A modern x86 core with AVX2 and fused multiply-add typically peaks around 48 GFLOPS at 3 GHz. GFLOPS alone says nothing about compute-bound vs memory-bound—it's only meaningful compared against peak or plotted against arithmetic intensity on a roofline.

GHZ state (Qiskit)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

GHZ state (Qiskit) GHZ state implementation using Qiskit. The three-qubit GHZ state $(\lvert 000\rangle + \lvert 111\rangle)/\sqrt{2}$ is prepared by applying a Hadamard gate to the first qubit and then chaining CX gates to spread the superposition to the remaining qubits. from qiskit import QuantumCircuit from qiskit.quantum_info import Statevector qc = QuantumCircuit(3) qc.h(0) # |000> -> (|000> + |100>) / sqrt(2) qc.cx(0, 1) # -> (|000> + |110>) / sqrt(2) qc.cx(0, 2) # -> (|000> + …

Docker (Reference)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

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't have it) docker run -it --rm ubuntu:latest Images Pull ubuntu:latest image

Git (Examples)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

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's in the staging area:

(WIP) semaphores (examples)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

(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$

Git branches

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Git branches Branches are pointers to commits. The default branch is usually main or master. Create a branch to experiment without affecting the main branch, then merge it back when ready. This is how teams work in parallel on different features without conflicts.

Git cherry-picking

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Git cherry-picking Cherry-picking applies a single commit from one branch to another. Instead of merging an entire branch, you select specific commits and replay them. This is useful for backporting bug fixes to an older release branch or copying a specific change without merging everything else the branch contains.

Git commits

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Git commits Commits are snapshots of your project at a point in time. Each commit has a unique hash, an author, a timestamp, message, and the full state of all tracked files. You can view history, revert to old commits, and understand who changed what and why.

Git conflicts

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Git conflicts Conflicts occur when two branches change the same lines and git cannot automatically merge them. Git marks the conflicting sections with <<<<<<<, =======, and >>>>>>> markers, showing both versions. You must manually choose which changes to keep, then stage and commit the resolved file.

Git history

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Git history Commit history is the record of all changes to your project. Use git log to view it, git show or git diff to see what changed, and git blame to find who changed each line and why. Understanding history helps you debug problems, understand design decisions, and audit who made what changes.

Git hooks

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Git hooks Hooks are scripts that run automatically when git events occur, such as before committing or after merging. Common hooks include pre-commit (run before creating a commit), post-merge (run after merging), and commit-msg (validate the commit message). Store hooks in

Git merging

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Git merging Merging combines two branches. Switch to the target branch (usually main) and run git merge to integrate changes. If git can automatically merge without conflicts, it creates a merge commit. If there are conflicts, you must resolve them manually before committing.

Git pushing and pulling

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Git pushing and pulling Pushing sends your commits to a remote; pulling fetches and merges from a remote. Push when you've committed changes locally and want to share them. Pull before pushing to avoid conflicts, and pull regularly to stay in sync with teammates.

Git rebasing

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Git rebasing Rebasing is reapplying commits from one branch onto another, creating a linear history. Instead of merging—which preserves both branches' histories—rebasing replays your commits on top of the target branch, as if you had started from that point. Use it to keep feature branches up to date or to clean up messy histories before merging.

Git remotes

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Git remotes Remotes are copies of your repository on another server, usually GitHub or GitLab. Push your commits to the remote so teammates can pull them. The default remote is called origin, created automatically when you clone. $ git remote -v # list remotes and their URLs $ git remote add # add a new remote $ git remote remove # remove a remote $ git branch -r # list remote branches

Git repositories

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Git repositories Repositories are folders managed by git. Initialize one with git init to start tracking changes. Git stores its metadata in a hidden .git/ subdirectory. Every developer gets a full copy of the repository including all history, so you can work offline and sync with others when ready.

Git staging

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Git staging Staging is where you prepare changes before committing. Use git add to stage files, then git commit to save them as a snapshot. Staging lets you pick which files go into each commit, so you can commit logically related changes together and keep unrelated changes separate.

Git stashing

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Git stashing Stashing temporarily saves uncommitted changes without committing them. Use it when you need to switch branches but do not want to commit your current work, or to clean your working directory before pulling. Stashes are local and private—they are not shared with remotes or other team members.

Git tags

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Git tags Tags mark specific commits, usually for releases. A lightweight tag is just a pointer to a commit, while an annotated tag stores the tagger's name, date, and a message, making it more suitable for releases. Tags are immutable markers, unlike branches, so they reliably mark points in history that matter.

Git undoing changes

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Git undoing changes Undoing in git means discarding or reverting changes. The strategy depends on whether changes are staged, committed, or already pushed. Never force-push to a shared branch; instead use git revert to create a new commit that undoes the old one.

Git workflows

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Git workflows Git workflows are team conventions for organizing branches and commits. Common patterns include trunk-based development (commit to main frequently, keep it stable), feature branches (one branch per feature, merge when done), or gitflow (main for releases, develop for integration, feature branches for work). Choose based on team size, release frequency, and how much isolation you need.

Git

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

Git Git is a version control system for tracking changes to code. Initialize a folder as a git repository to save snapshots of your work, branch to experiment safely, and synchronize with teammates via remotes. Every change is recorded as a commit, a snapshot of your project at a point in time. You can view history, revert to old commits, and understand who changed what and why. Git is decentralized—each person gets a full copy of the repository's history, so you work offline and sync with oth…

.gitignore

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

.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` *

Global phase

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

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…

Google quantum AI

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

Google quantum AI Google Quantum AI builds on Transmon qubits, the same family as IBM quantum, arranged in a 2D grid with each qubit tunably coupled to its neighbors. Its Sycamore processor produced the first widely publicized claim of quantum computational advantage in 2019, running a random circuit sampling task. That claim was later narrowed as classical simulation techniques improved.

Graph

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

Graph A graph is a structure consisting of a set of vertices (nodes) and a set of edges that connect pairs of vertices. Edges can be directed (one-way, like a one-way street) or undirected (bidirectional). Edges can carry a weight representing cost, distance, or capacity. Graphs model any relationship between entities: road networks, dependency graphs, social networks, circuit netlists, and state machines.

Grover

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

Grover Grover'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 s\rangle\la…

Gustafson's law

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

Gustafson's law Gustafson's law models speedup when problem size grows with hardware (weak scaling), yielding near-linear speedup: $S(n) = n - \alpha(n-1)$ where $\alpha$ is the sequential fraction. Unlike Amdahl's law, speedup grows with processor count, making it applicable to most HPC workloads that scale problem size with available hardware.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

provides the assert macro for runtime checking during development. It evaluates a condition and terminates the program with a diagnostic message showing the file, line, and failed condition if it's false. Assertions are stripped entirely when compiled with

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

provides _Complex type (C99) and complex number functions: magnitude (cabs), phase (carg), conjugate (conj), and full trigonometric/exponential support. Arithmetic operators work natively on complex types. Use it for signal processing, electrical engineering, and quantum mechanics where complex arithmetic is essential.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

provides character classification (isalpha, isdigit, isspace) and conversion (toupper, tolower). These functions handle the full range of unsigned char correctly and respect locale. Always cast to unsigned char when passing chars to avoid undefined behavior with negative signed values.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

(typically ) provides terminal control for building text-based user interfaces: window creation, cursor positioning, text attributes, and input handling. It translates portable abstractions into the right escape sequences for any terminal.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

provides errno, a thread-local variable that functions set to indicate why they failed. Common codes: ENOENT (no file), EACCES (permission denied), EINVAL (invalid argument). Only check errno immediately after a function that failed; successful calls may overwrite it, giving you meaningless noise.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

provides access to the floating-point environment: exception flags that record invalid operations, overflows, and underflows, plus rounding mode control. Essential for checking whether computations silently produced NaN or infinity.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

defines platform-specific floating-point limits: DBL_EPSILON (smallest difference from 1.0), DBL_MAX, DBL_MIN, and precision constants. Essential for writing numerically robust code across platforms. Use DBL_EPSILON as the basis for floating-point comparisons instead of exact equality.

Hadamard gate (CUDA-Q)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

Hadamard gate (CUDA-Q) Hadamard gate implementation using CUDA-Q. // Compile: nvq++ main.cpp -o main // Run: ./main #include struct kernel { __qpu__ void operator()() { cudaq::qubit q; h(q); // |0> -> |+> mz(q); } }; int main() { auto counts = cudaq::sample(kernel{}); counts.dump(); // ~50% |0>, ~50% |1> }

Hadamard gate (cuStateVec)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

Hadamard gate (cuStateVec) Hadamard gate implementation using cuStateVec. // Compile: nvcc main.cu -o main -lcustatevec // Run: ./main #include #include #include #include int main() { const int nQubits = 1; const int dim = 1 << nQubits; cuDoubleComplex h_sv[2] = {{1,0},{0,0}}; // |0> cuDoubleComplex *d_sv; cudaMalloc(&d_sv, dim * sizeof(cuDoubleComplex)); cudaMemcpy(d_sv, h_sv, dim * sizeof(cuDoubleComplex), cu…

Hadamard gate (Qiskit)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

Hadamard gate (Qiskit) Hadamard gate implementation using Qiskit. from qiskit import QuantumCircuit from qiskit.quantum_info import Statevector qc = QuantumCircuit(1) qc.h(0) # |0> -> |+> = (|0> + |1>) / sqrt(2) print(Statevector(qc)) # Statevector([0.70710678+0.j, 0.70710678+0.j], dims=(2,))

Hadamard gate

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00

Hadamard gate Hadamard gate (or H gate) is a single-qubit gate that maps the computational basis states $\lvert 0\rangle$ and $\lvert 1\rangle$ to equal superpositions. It is the most commonly used gate for creating superposition and appears at the start of most quantum algorithms. $$H = \frac{1}{\sqrt{2}}\begin{pmatrix}1 & 1\\ 1 & -1\end{pmatrix}$$$$H\lvert 0\rangle = \frac{\lvert 0\rangle + \lvert 1\rangle}{\sqrt{2}} = \lvert +\rangle \qquad H\lvert 1\rangle = \frac{\lvert 0\rangle - \lvert 1…

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

(POSIX/GNU) provides getopt for short options (-v, -o file) and getopt_long for long options (--verbose, --output=file). It handles argument parsing, optarg tracking, and stops at the first non-option argument or --. Use it to parse command-line arguments portably instead of handling

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

solves a portability trap: uint64_t may be unsigned long on one platform and unsigned long long on another. The format macros (PRIu64, PRIx64) expand to the correct printf/scanf specifier for each platform. Use PRIu64, PRId64

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

provides alternative spellings for operators as macros: and for &&, or for ||, not for !, bitand for &, etc. It exists for platforms where these symbols were assigned to other characters. In C++, these are built-in keywords; in C, you need this header. Rarely needed on modern systems.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

provides platform-specific integer type limits: INT_MAX, INT_MIN, UINT_MAX, LONG_MAX, etc. Use these when writing portable code that works correctly regardless of whether integers are 32 or 64 bits. Never hardcode values like

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

controls culture-specific formatting: decimal separators, currency symbols, sorting order. By default programs run in the "C" locale (ASCII, . decimal); call setlocale(LC_ALL, "") to use the user's environment locale. Be careful with

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

provides standard math functions: trigonometric, exponential, logarithmic, rounding, and IEEE 754 utilities (isnan, isinf). Append f for float or l for long double versions. Compile with -lm to link the math library. Example This example demonstrates basic math functions and special-value checking.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

provides setjmp and longjmp for non-local jumps: save the current execution context and jump back to it from a deeply nested function, bypassing normal return chains. It's the C equivalent of exceptions but without cleanup machinery.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

provides signal handling for asynchronous events: SIGINT (Ctrl+C), SIGTERM, SIGSEGV, etc. Register a handler with signal(SIGNUM, handler). Handlers run asynchronously and can only safely call async-signal-safe functions like write

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

provides alignas() and alignof() (C11) for memory alignment control. alignof(type) returns its alignment requirement; alignas(N) forces a variable or struct member to align to N bytes. Use it for SIMD operations, hardware register access, or matching binary layouts.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

provides va_list, va_start(), va_arg(), and va_end() for implementing variadic functions accepting a variable number of arguments. The caller must ensure type safety—there's no runtime checking that passed arguments match what the function expects.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

provides _Atomic type and lock-free atomic operations for thread synchronization (C11). Atomic operations complete without interruption and support compare-and-swap for building lock-free data structures. Memory order control (

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

provides standard bit manipulation (C23): stdc_popcount (population count), stdc_leading_zeros, stdc_trailing_zeros, stdc_rotl, stdc_rotr. Previously you needed GCC builtins or platform-specific code. Use it for portable bit operations without compiler-specific extensions.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

provides bool, true, and false (C99) as portable names for the _Bool type. Assigning any non-zero value to bool produces 1, unlike int where 42 stays 42. In C23, bool became a built-in keyword, but including the header remains portable and harmless.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

provides checked arithmetic macros (C23): ckd_add, ckd_sub, ckd_mul. They perform the operation and return true if overflow occurred, false otherwise, without triggering undefined behavior. Use these instead of manual overflow checks for cleaner, safer code.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

provides fundamental types and macros: size_t (for sizes), ptrdiff_t (pointer differences), wchar_t, NULL, and offsetof(). Most headers include it transitively, but it's essential to include directly for portable code. Use size_t

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

provides fixed-width integer types (C99): int8_t, uint32_t, int64_t, etc., guaranteeing exact widths across platforms. Also includes intmax_t, intptr_t, and limit macros like INT32_MAX. Use fixed-width types for binary I/O, hardware registers, and portable low-level code.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

provides buffered file and console I/O: printf, scanf, fopen, fclose, and stream operations. Use snprintf instead of sprintf to avoid buffer overflows; always check return values. Compile with -lm if using math functions; I/O functions link with the C library automatically.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

covers memory allocation (malloc, calloc, free), type conversion (atoi, strtol), sorting/searching (qsort, bsearch), and process control (exit, abort). It's the “junk drawer” of the C standard library. Always check malloc for NULL; always check

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

is a proposed C header (C2y/C3x) designed to fix Unicode handling deficiencies in and with cleaner, safer APIs. As of C23, it is not yet standardized and compilers do not ship it. When standardized, it will provide portable UTF-8 to local encoding transcoding without platform-specific APIs.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

provides the noreturn macro (C11), which tells the compiler a function never returns—useful for die() or fatal() functions that always exit. This suppresses false warnings about missing returns and enables better dead-code elimination.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

provides null-terminated string functions (strlen, strcpy, strcat, strcmp) and memory operations (memcpy, memmove, memset). Avoid strcpy/strcat (unsafe); use bounded variants or snprintf instead. The mem* functions work on raw bytes; the

Anonymous (anonymous@undisclosed.example.com) — 2026-08-24T23:48:50+00:00

provides type-generic math wrappers (C99) so you can write sqrt instead of sqrtf/sqrt/sqrtl. The dispatcher selects the right function based on argument type at compile time. Precision-critical code often prefers explicit suffixes for clarity.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

provides portable threading (C11): thrd_create, thrd_join, mutexes, and condition variables. Linux mainly uses POSIX pthreads instead, since threads.h support was added to glibc only recently (2022). Use threads.h for new portable C11 code; use pthreads for existing Linux code.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

provides time functions: time() for wall-clock seconds since epoch, clock() for CPU time, struct tm for broken-down calendar time, and strftime() for formatting. Use clock_gettime(CLOCK_MONOTONIC, ...) for nanosecond-resolution wall-clock timing.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

provides char16_t and char32_t with fixed, portable UTF-16 and UTF-32 encodings (C11). Conversion functions translate between multibyte (UTF-8) and these encodings, suitable for portable Unicode handling. Use this instead of wchar_t

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

provides wide-character functions (C95): wprintf, wcslen, wcscmp, etc. The encoding of wchar_t is platform-dependent (UTF-32 on Linux, UTF-16 on Windows), making portable Unicode code difficult. For portable Unicode, prefer

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00

provides wide-character classification (iswalpha, iswdigit, iswspace) and case conversion (towupper, towlower). These functions work on full Unicode via wchar_t, unlike which handles only ASCII. Results depend on locale; call

Harvard architecture

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

Harvard architecture Harvard archictecture is a type of computer archictecture. It'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't really matter, of course

Hash map

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

Hash map A hash map (also called a hash table) is a data structure that maps arbitrary keys to values in O(1) average time. A hash function converts a key to an integer index into a backing Array of buckets. The ideal hash function distributes keys uniformly so that each bucket holds roughly one entry; when two keys hash to the same bucket, that is a

Hazard pointer

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

Hazard pointer Hazard pointer is a memory reclamation mechanism for lock-free structures where a thread publishes pointers it's about to dereference into well-known slots. Other threads scan these slots before freeing nodes, ensuring safe deferred-free. It trades per-read overhead (publish, verify, clear) for prompt memory reclamation once no thread's slots reference a node.

Heap

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

Heap A heap is a Binary tree stored in an Array that maintains the heap property: in a max-heap, every parent is greater than or equal to its children, so the maximum element is always at the root. In a min-heap the relationship is reversed and the minimum is at the root. The tree is

HHL algorithm

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

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}$…

Hilbert space

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

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$

Home

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T12:22:13+00:00

Home Hi, I'm Ivan! This website is my personal encyclopedia about various technical topics. The topics I cover on this wiki are mostly related to technology, but on occasion I also write about mathematics and physics. Three major topics on this website are: 1.

Hopf fibration

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

Hopf fibration The Hopf fibration is a map from the three-sphere onto the two-sphere whose preimages are circles, written $S^1 \hookrightarrow S^3 \xrightarrow{\ h\ } S^2$. Every point of $S^2$ pulls back to a full circle in $S^3$, no two of those circles meet, and together they fill $S^3$ exactly once. It matters here because it is not an abstraction invented for its own sake: a single qubit state is a point of $S^3$$E$$B$$F$$\pi : E \to B$$B$$U$$\pi^{-1}(U)$$U \times F$$S^1 \times [0,1]$$S^1$…

HPC

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00

HPC High-Performance Computing (HPC) is the practice of extracting maximum computational power from available hardware. Write code that scales across multiple cores, optimize memory access patterns, and profile performance bottlenecks to maximize throughput. HPC spans multi-core CPUs, GPUs, and distributed clusters—from a laptop running OpenMP to supercomputers with thousands of nodes.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides a library of generic algorithms that operate on ranges of elements: searching, sorting, transforming, and counting. These functions work with any container that provides iterators (vectors, lists, arrays), and they follow a consistent prefix convention for variants (

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides std::any, a type-safe container that can hold a value of any type. At runtime, you check the held type with type() and extract it with std::any_cast(), which throws if the held type doesn't match. It's useful when you need a heterogeneous collection or when a value's type is not known until runtime, such as config options, plugin return values, or generic event payloads.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides std::array, a fixed-size array wrapper around a C array. It behaves like a container with .begin(), .end(), .size(), but with zero runtime overhead compared to a raw array. Use it whenever you want the safety of STL containers (bounds checking with

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides std::atomic for lock-free shared data between threads. Atomic operations guarantee visibility and ordering without explicit locks, which is critical for low-latency multithreaded code. Each atomic operation specifies a memory ordering constraint (

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides a synchronization point where a fixed number of threads wait until all have arrived. Once the count is reached, all are released together. It's useful for parallel algorithms where you need all workers to complete a stage before proceeding to the next, such as in phase-based simulations or MapReduce-style processing.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides bit manipulation utilities introduced in C++20: std::popcount (count set bits), std::countl_zero / std::countr_zero (leading/trailing zeros), std::rotl / std::rotr (rotate), and std::byteswap. These are thin wrappers around intrinsics like

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

is a fixed-size bitfield: each bit is independently addressable and can be set, cleared, or tested. It's more memory-efficient than std::vector for large fixed-size bit arrays. Use it for flags, masks, or when you need to track individual bits of a large quantity—like tracking active threads in a thread pool or implementing a sparse boolean matrix.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides fast, locale-independent number-to-string and string-to-number conversion via std::to_chars and std::from_chars. Unlike std::stoi or string streams, these don't throw exceptions—they return an error code and the number of characters consumed. It's used in performance-critical paths like serialization, parsing CSV, or network protocols where you want predictable performance without locale assumptions.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides time utilities: std::chrono::system_clock (wall time), std::chrono::steady_clock (monotonic, never goes backwards), and std::chrono::high_resolution_clock (highest precision available). You work with duration (a time interval) and

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides locale-based character encoding conversion facets, primarily for converting between UTF-8, UTF-16, and UTF-32. It's part of the locales system, which is complex and largely superseded by explicit UTF-8 handling in modern C++. Most new code avoids this in favor of dedicated UTF-8 libraries or C++20

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides the three-way comparison operator <=> (spaceship operator) and comparison result types (std::strong_ordering, std::weak_ordering, std::partial_ordering) introduced in C++20. It allows you to define a single operator<=> that automatically generates

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides std::complex for complex numbers with arithmetic operations, trigonometric functions, and conversions. It's useful for signal processing, control theory, and wave simulations. Operations like abs(), arg(), conj(), polar()

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides standard concepts (type constraints) introduced in C++20: std::integral, std::floating_point, std::regular, std::equality_comparable, etc. A concept is a compile-time predicate on types that lets you write generic code with enforced requirements. Use concepts to constrain template parameters so that invalid instantiations fail with clear error messages rather than cryptic SFINAE errors deep in the template.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides std::condition_variable for efficient thread coordination: one or more threads wait on a condition, and others signal when it changes. It pairs with a std::mutex to avoid race conditions around the condition check. This is the go-to tool for producer-consumer queues, thread-safe event systems, and any scenario where a thread should sleep until a specific event occurs.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides the low-level coroutine machinery (promise types, coroutine handles, awaiters) for implementing stackless coroutines in C++20. Coroutines can suspend and resume without threads, enabling async I/O and lazy generators. The header itself is foundational; you typically use higher-level abstractions like

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

(double-ended queue) is like a vector but allows efficient insertion and deletion at both ends. Iterating and random access are O(1), but not as cache-friendly as vector for linear scans. Use it when you need to push/pop from both front and back; otherwise prefer

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides the base class std::exception and utilities for exception handling: std::terminate_handler, std::exception_ptr (capture and rethrow exceptions across threads), and std::rethrow_exception. Most user code catches specific exceptions derived from

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides execution policies for parallel algorithms introduced in C++17: std::execution::seq (sequential), std::execution::par (parallel), std::execution::par_unseq (parallel, unsequenced), std::execution::unseq (unsequenced, C++20). These policies are passed to algorithms like

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides portable file and directory operations: std::filesystem::path, std::filesystem::exists, std::filesystem::is_regular_file, std::filesystem::directory_iterator, etc. It abstracts away differences between POSIX and Windows paths. Use it for any code that creates, lists, or inspects files and directories. It's far better than hand-written string manipulation with

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides std::format, a type-safe, fast, printf-style formatting function introduced in C++20. It replaces most uses of sprintf, string streams, and std::cout manipulators. It supports compile-time format string checking (in some implementations) and is faster than stream-based formatting.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

is a singly-linked list: fast insertion and deletion at the front (O(1)), but no random access and reverse iteration. It uses less memory than std::list and can be faster in practice due to better cache locality. Use it when you need a linked list and only iterate forward; otherwise prefer

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides std::ifstream (input), std::ofstream (output), and std::fstream (bidirectional) for file I/O. They wrap C's FILE* with the iostream interface, handling mode flags and automatic cleanup via RAII. Use it for all file reading and writing; avoid

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides function wrappers and factories: std::function (type-erased callable), std::bind (partial application), and std::mem_fn (convert member function pointers to function objects). It also includes standard comparators and arithmetic function objects.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides std::future and std::promise for passing values or exceptions between threads. std::async launches a function on a thread pool (or synchronously, depending on the policy) and returns a future that you wait on for the result. It's the standard way to express

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides std::initializer_list, which lets you write constructors and functions that accept brace-enclosed lists like std::vector{1, 2, 3}. It's a lightweight, read-only view over a compiler-managed array. Use it to enable uniform initialization syntax on your own types.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides stream manipulators for formatting output: std::setw, std::setprecision, std::setfill, std::hex, std::oct, std::fixed, std::scientific. They temporarily modify the stream state for a single output operation. Most modern code prefers

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

defines the base classes for input/output streams: std::ios_base, std::basic_ios. It handles stream state (good, fail, eof), format flags, and locale. Most user code works with derived classes like std::cin, std::cout, std::fstream, and doesn't interact with this header directly.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides forward declarations of stream classes without including the full implementation. Use it in header files when you want to accept a stream parameter or return type without pulling in the heavy iostream headers. It's a small optimization to reduce compile times.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides std::cin, std::cout, std::cerr, std::clog for standard I/O. It's the C++ way to read from stdin and write to stdout/stderr. Use std::cout for normal output, std::cerr for errors, and std::cin for input. For formatted output, prefer

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

defines std::basic_istream and std::istream, the base classes for input streams. It provides operator>> for formatted input, get(), getline(), and read() for unformatted input. You rarely use this directly; instead you use concrete classes like

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides iterator utilities: std::advance, std::distance, std::next, std::prev, iterator type traits like std::iterator_traits, and iterator adapters like std::back_inserter, std::insert_iterator. Use iterator adapters to turn algorithms into list-building operations:

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides std::latch, a simple synchronization primitive that counts down to zero. Threads call count_down() or count_down_and_wait() to decrement; other threads call wait() to block until the count reaches zero. Unlike std::barrier, a latch is one-time use. It's useful for waiting for a fixed number of async tasks to complete.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides std::numeric_limits, a traits class that gives you compile-time constants about numeric types: std::numeric_limits::max(), std::numeric_limits::epsilon(), etc. Use it to write generic code that adapts to the numeric type without hardcoding values.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

is a doubly-linked list with fast insertion and deletion anywhere you have an iterator, but O(n) random access. Use it when you frequently insert/remove in the middle; otherwise prefer std::vector. Unlike std::forward_list, you can iterate backwards and erase from both ends.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides locale-aware facets for character classification, collation, number/currency formatting, and time display. Most code avoids it in favor of simpler, more portable alternatives. If you need to handle locale-specific collation or formatting in a GUI application, this is where to look; otherwise keep everything in the C locale or use explicit format strings.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

is an ordered associative container: a sorted tree of key-value pairs with O(log n) insertion, deletion, and lookup. It maintains keys in sorted order and allows iteration from min to max. Use std::unordered_map if you don't need order; use

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides polymorphic memory allocators: std::pmr::memory_resource and standard containers adapted to use them, like std::pmr::vector, std::pmr::string. This allows switching allocators (stack, arena, monotonic) at runtime without changing container types. Use it when you need custom allocation strategies; most code just uses the default allocator.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides smart pointers—std::unique_ptr (exclusive ownership), std::shared_ptr (reference-counted ownership)—and std::make_unique, std::make_shared factories. Smart pointers automatically delete memory via RAII, preventing leaks and use-after-free. Use

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides std::mutex for mutual exclusion, and std::lock_guard / std::unique_lock for RAII-based locking. Always lock via a lock guard to ensure the lock is released even if an exception is thrown. Use std::lock_guard for simple cases; use

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

defines operator new and operator delete for memory allocation. You can overload them for custom allocation behavior or set a custom new_handler function to be called if allocation fails. Most code never needs this; just use smart pointers from

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides mathematical constants (C++20): std::numbers::pi, std::numbers::e, std::numbers::sqrt2, etc. The constants are exact as double by default, but you can specialize them for other floating-point types. Use these instead of hardcoding

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides numeric algorithms: std::accumulate (sum), std::inner_product (dot product), std::adjacent_difference, std::partial_sum, std::iota (fill with sequence). Use these for numerical operations on ranges; they work with any container that has iterators.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

represents a value that may or may not be present, a type-safe alternative to returning a null pointer or sentinel value. Use .has_value() or the conversion operator to check, and .value() or * to access the contained value. It's useful for functions that may fail to produce a value but don't need to throw or use exceptions.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

defines std::basic_ostream and std::ostream, the base classes for output streams. It provides operator<< for formatted output, put(), write(), and flush(). Most code uses std::cout or file output streams that inherit from this class.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides std::queue (FIFO) and std::priority_queue (min/max heap). They are container adapters—wrappers around a deque or vector that expose only the queue semantics. Use queue for FIFO (front end, back end), and priority_queue

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides random number engines (std::mt19937, std::random_device) and distributions (std::uniform_int_distribution, std::normal_distribution). Engine and distribution are separate to allow reusing an engine with different distributions. Always seed with a good entropy source:

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides the ranges library (C++20): a new way to express algorithms that works on ranges directly instead of iterator pairs. Instead of std::sort(v.begin(), v.end()), you write std::ranges::sort(v). Range adapters like std::views::filter

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides compile-time rational number arithmetic via std::ratio. Ratios are commonly used as template parameters for durations (e.g., std::chrono::milliseconds is std::ratio<1, 1000>). Most code doesn't use this directly; you encounter it when working with

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides regular expression matching via std::regex, std::regex_match, std::regex_search, and std::regex_replace. The syntax defaults to ECMAScript (JavaScript-like) regex. C++ regex is slower than dedicated libraries like oniguruma or

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides std::scoped_allocator_adaptor, which propagates an allocator to nested containers. Normally, a vector's allocator doesn't apply to the strings it contains; this adaptor fixes that, ensuring all nested allocations use the same custom allocator. Use it only when you have a custom allocator you want to apply recursively throughout a container hierarchy.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides std::binary_semaphore (0 or 1, like a lock) and std::counting_semaphore (up to N resources available). Threads call acquire() to decrement the count (blocking if zero) and release() to increment. Use semaphores for limiting access to a fixed pool of resources.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

is an ordered container of unique elements, maintained in sorted order via a red-black tree. Insertion, deletion, and lookup are O(log n). Use std::multiset to allow duplicates. Use std::set when you need a sorted unique collection; use

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides std::shared_mutex for reader-writer synchronization: multiple readers can hold the lock simultaneously, but a single writer has exclusive access. Use std::shared_lock for readers and std::unique_lock

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides std::source_location, which captures the filename, line number, column, and function name at the call site (C++20). It's useful for better error messages, logging, or assertions that show where they were invoked. Use it in library functions to provide context-aware diagnostics.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

is a non-owning view over a contiguous range of elements (C++20): it holds a pointer and length, allowing you to pass array data without copying. Use it as a function parameter to accept any contiguous container. It's like a safer const T*

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides std::istringstream, std::ostringstream, and std::stringstream for in-memory string I/O. Use them to parse or format strings with the iostream interface. They're slower than direct string manipulation or std::format, but are useful for portable formatted I/O without file overhead.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

is a LIFO container adapter: you push on the top and pop from the top. It's built on top of a deque or vector and exposes only stack semantics. Use it when you need a simple LIFO data structure; otherwise use a vector directly. This example demonstrates push, pop, and top operations on a LIFO stack, showing last-in-first-out ordering.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

defines standard exception classes: std::logic_error (programming error), std::runtime_error (runtime failure), and their subclasses (std::invalid_argument, std::out_of_range, std::overflow_error, etc.). Derive your own exceptions from these when you need domain-specific errors.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides std::stop_token and std::stop_source for cooperative cancellation (C++20). A stop_token can be checked to see if cancellation was requested, and callbacks can be registered to run when cancellation occurs. Use it to enable graceful shutdown of background tasks without forceful thread termination.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides std::basic_streambuf, the base class for stream buffers. You rarely derive from this unless you're implementing custom input or output streams. Most code just uses the derived classes provided by ,

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides std::string_view, a non-owning view over a character sequence (C++17). It holds a pointer and length, allowing you to pass string data without copying or null-terminating. Use it as a function parameter when you don't need ownership; it accepts both

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides std::string (mutable) and std::string_view (read-only, C++17). std::string is a dynamic array of characters with O(1) amortized append, O(1) random access, and utilities like find(), substr(), replace(). Use std::string for owned text; use

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides std::osyncstream, a wrapper around std::ostream that buffers output and flushes it atomically, preventing interleaved writes from multiple threads (C++20). Use it when multiple threads write to the same stream and you want each logical message to be atomic.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides std::error_code and std::error_category for OS-level error reporting. Use it to portably capture and classify system errors (like errno or Windows HRESULT) without hardcoding values. Most code doesn't use this directly; it's used internally by file operations and network APIs.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides std::thread for creating and managing threads, and std::jthread (C++20) which automatically joins on destruction. Create a thread by passing a callable and arguments; join to wait for completion. Use std::jthread in new code when available; it prevents accidental detached threads.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

provides std::tuple, a heterogeneous fixed-size container holding values of different types. Use std::get(t) to access by index or std::get(t) to access by type. C++17 structured bindings (auto [x, y] = tuple) make tuples convenient. Tuples are useful for returning multiple values from a function without defining a struct.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
provides type introspection and transformation templates: std::is_integral, std::is_pointer, std::remove_reference, std::enable_if, and many others. Use them to write generic code that adapts to type properties at compile time. Concepts (C++20) often replace manual type trait checks, but traits remain useful for SFINAE and metaprogramming.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
provides std::type_index, a hashable wrapper around std::type_info from . Use it to store types in containers like std::map or std::unordered_map. You rarely need this; it's mainly useful for dynamic type dispatch or plugin systems.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
provides std::type_info, an object that holds type metadata available at runtime (via typeid()). You can compare type_info objects, get a name (though it's mangled), or use before() to sort types. Use it for runtime type identification; wrap it in

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
is a hash table of key-value pairs with O(1) average insertion, deletion, and lookup. Keys are unordered, but you can iterate and access by key quickly. Use unordered_map when you need fast lookup by key; use std::map

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
is a hash table of unique elements with O(1) average insertion, deletion, and lookup. Elements are unordered but quickly accessible. Use unordered_set for fast membership testing; use std::set if you need sorted order.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
provides miscellaneous utilities: std::pair (a two-element tuple), std::move (enable move semantics), std::forward (perfect forwarding), std::swap, and std::exchange. std::pair is the building block for map key-value pairs, and

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
provides std::valarray, a vector-like container optimized for mathematical operations: elementwise operations, slicing, and masking. Most scientific code uses Eigen or NumPy instead. valarray has an odd API and is rarely used in practice.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
is a type-safe union: it holds a value of one of the possible types (C++17). Use std::holds_alternative(v) to check which type is held, and std::get(v) to access the value (throws if wrong type). It's more elegant than std::any

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
provides std::vector, a dynamic array with O(1) amortized append, O(1) random access, and O(n) insertion/deletion in the middle. It grows exponentially as you push elements, minimizing reallocations. Use vector for almost any sequence of elements; it's the default choice for ordered containers.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
provides __cpp_* feature-test macros (C++20) that tell you which C++ features are available in your compiler and standard library. For example, __cpp_concepts is defined if C++20 concepts are supported. Use these in preprocessor conditionals to enable features selectively.

Hidden subgroup problem

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
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…

I gate (CUDA-Q)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
I gate (CUDA-Q) I gate implementation using CUDA-Q. // Compile: nvq++ main.cpp -o main // Run: ./main #include struct kernel { __qpu__ void operator()() { cudaq::qubit q; h(q); // prepare |+> // identity is a no-op; the state is unchanged mz(q); } }; int main() { auto counts = cudaq::sample(kernel{}); counts.dump(); // ~50% |0>, ~50% |1> }

I gate (cuStateVec)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
I gate (cuStateVec) I gate implementation using cuStateVec. // Compile: nvcc main.cu -o main -lcustatevec // Run: ./main #include #include #include int main() { const int nQubits = 1; const int dim = 1 << nQubits; cuDoubleComplex h_sv[2] = {{1,0},{0,0}}; // |0> cuDoubleComplex *d_sv; cudaMalloc(&d_sv, dim * sizeof(cuDoubleComplex)); cudaMemcpy(d_sv, h_sv, dim * sizeof(cuDoubleComplex), cudaMemcpyHostToDevice); cust…

I gate (Qiskit)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
I gate (Qiskit) I gate implementation using Qiskit. from qiskit import QuantumCircuit from qiskit.quantum_info import Statevector qc = QuantumCircuit(1) qc.h(0) # prepare |+> qc.id(0) # identity — state unchanged print(Statevector(qc)) # Statevector([0.70710678+0.j, 0.70710678+0.j], dims=(2,))

I gate

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
I gate I gate (or identity gate) is a single-qubit quantum gate that leaves the state of a qubit unchanged. It is represented by the $2 \times 2$ identity matrix and drawn as a plain wire in quantum circuit diagrams. $$I = \begin{pmatrix}1 & 0\\ 0 & 1\end{pmatrix}$$ The identity gate is trivial on its own but appears in multi-qubit notation to indicate that a qubit is carried through a time step without any operation being applied. For example, applying $H$$H \otimes I$

$\lvert i\rangle$ (Qiskit)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
$\lvert i\rangle$ (Qiskit) Plus-i state $\lvert i\rangle$ implementation using Qiskit. The $\lvert i\rangle$ state is prepared by applying a Hadamard gate followed by an S gate to $\lvert 0\rangle$. from qiskit import QuantumCircuit from qiskit.quantum_info import Statevector qc = QuantumCircuit(1) qc.h(0) # |0> -> |+> qc.s(0) # |+> -> |i> = (|0> + i|1>) / sqrt(2) print(Statevector(qc)) # Statevector([0.70710678+0.j, 0.+0.70710678j], dims=(2,))

IBM quantum

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
IBM quantum IBM Quantum builds on Transmon qubits: circuits built around Josephson junctions that behave as artificial atoms with quantized energy levels. Chips are cooled to near absolute zero in dilution refrigerators, and qubits are controlled and read out with microwave pulses tuned to each qubit's transition frequency.

ifupdown

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
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

import argparse

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
import argparse import argparse is a Python import that parses command-line arguments with automatic help generation. Use it to accept options and positional arguments in CLI scripts. Example # Python # description: parse command-line arguments import argparse parser = argparse.ArgumentParser(description="Process files") # Positional argument parser.add_argument("input", help="Input file") # Optional arguments parser.add_argument("-o", "--output", default="out.txt", help="Output file") p…

import collections

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
import collections import collections is a Python import that provides specialized container types: Counter, defaultdict, OrderedDict, namedtuple, and deque. Use these when the standard dict, list, and tuple don't fit your use case. Example # Python # description: count elements, use defaultdict, create namedtuple from collections import Counter, defaultdict, namedtuple # Count occurrences words = ["apple", "banana", "apple", "cherry", "apple"] counts = Counter(words) print(counts["apple"]…

import contextlib

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
import contextlib import contextlib is a Python import that provides utilities for creating context managers. Use @contextmanager to write with statement handlers for setup/cleanup. Example # Python # description: create context managers, suppress exceptions from contextlib import contextmanager, suppress import os # Create context manager from generator @contextmanager def working_directory(path): """Change to directory, then restore.""" old_cwd = os.getcwd() os.chdir(path) …

import dataclasses

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
import dataclasses import dataclasses is a Python import that auto-generates methods for classes that mainly store data. Use @dataclass to reduce boilerplate for simple classes. Example # Python # description: define data classes with auto-generated methods from dataclasses import dataclass, field from typing import List @dataclass class Person: name: str age: int email: str = "unknown@example.com" # default value # Create instance p = Person("Alice", 30) print(p) # Person(n…

import datetime

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
import datetime import datetime is a Python import that provides date, time, and timezone handling. Use it for creating timestamps, calculating date differences, and formatting dates for display. Example # Python # description: work with dates and times from datetime import datetime, timedelta, date # Current time now = datetime.now() print(now) # 2025-08-24 15:30:45.123456 # Create specific date/time d = datetime(2025, 12, 25, 10, 30) print(d.year, d.month, d.day) # Time differences to…

import enum

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
import enum import enum is a Python import that defines enumerations: fixed sets of symbolic names. Use Enum to create cleaner code than magic strings. Example # Python # description: define and use enumerations from enum import Enum, auto class Status(Enum): PENDING = "pending" ACTIVE = "active" COMPLETED = "completed" # Access enum members print(Status.PENDING) # Status.PENDING print(Status.PENDING.value) # pending # Use in code current_status = Status.ACTIVE if current_s…

import functools

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
import functools import functools is a Python import that provides functional programming tools: function caching, partial application, and wrapping functions with decorators. Example # Python # description: cache function results, partial application from functools import lru_cache, partial, wraps # Cache function results (memoization) @lru_cache(maxsize=128) def fibonacci(n): if n < 2: return n return fibonacci(n-1) + fibonacci(n-2) print(fibonacci(10)) # Fast due to ca…

import io

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
import io import io is a Python import that provides in-memory file-like objects. Use StringIO to treat strings as files, and BytesIO for binary data. Example # Python # description: read/write to in-memory file objects import io # String buffer string_buffer = io.StringIO() string_buffer.write("Hello, ") string_buffer.write("World!") # Get contents contents = string_buffer.getvalue() print(contents) # Hello, World! # Read from string buffer string_buffer.seek(0) # Reset to start print…

import itertools

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
import itertools import itertools is a Python import that provides efficient iteration tools: combinations, permutations, chaining iterables, and infinite counters. Use these for combinatorics and lazy evaluation. Example # Python # description: combinations, permutations, infinite count import itertools # Combinations (no order) combos = itertools.combinations("ABC", 2) print(list(combos)) # [('A', 'B'), ('A', 'C'), ('B', 'C')] # Permutations (all orderings) perms = itertools.permutatio…

import json

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
import json import json is a Python import that serializes and deserializes JSON data. Use json.dumps() to convert Python objects to JSON strings, and json.loads() to parse JSON strings into Python dicts and lists. Example # Python # description: parse JSON string, serialize to JSON import json # Parse JSON string data = json.loads('{"name": "Alice", "age": 30}') print(data['name']) # Alice # Serialize Python dict to JSON string person = {"name": "Bob", "age": 25, "skills": ["Python", "C…

import logging

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
import logging import logging is a Python import that logs messages at different severity levels: DEBUG, INFO, WARNING, ERROR, CRITICAL. Use it instead of print() for production code. Example # Python # description: configure logging, log at different levels import logging # Configure basic logging logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s") # Log messages logging.debug("Debug message (not shown)") logging.info("Applicat…

import math

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
import math import math is a Python import that provides mathematical functions and constants. Use it for trigonometry, logarithms, rounding, and accessing π and e. Example # Python # description: math functions and constants import math # Constants print(math.pi) # 3.14159... print(math.e) # 2.71828... # Trigonometry angle = math.radians(45) print(math.sin(angle)) # 0.707... print(math.cos(angle)) # 0.707... # Logarithms and exponentials print(math.log(100)) # natural lo…

import os

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
import os import os is a Python import that provides functions for interacting with the operating system: file paths, environment variables, process information, and filesystem operations. Use this for cross-platform file handling, reading environment, and running system commands.

import pathlib

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
import pathlib import pathlib is a Python import that provides object-oriented filesystem paths. Prefer pathlib.Path over os.path for modern code; it's more readable and handles cross-platform paths automatically. Example # Python # description: create paths, check existence, read files from pathlib import Path # Create a path object p = Path("data/config.txt") # Check if file exists if p.exists(): print(f"File exists at {p.resolve()}") # Get file properties print(f"Size: {p.stat().s…

import random

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
import random import random is a Python import that generates pseudo-random numbers. Use it for shuffling, sampling, and generating random values for simulations and games. Example # Python # description: random numbers, shuffling, sampling import random # Random float between 0 and 1 x = random.random() print(x) # 0.37... # Random integer in range die_roll = random.randint(1, 6) print(die_roll) # Random choice from list choice = random.choice(["apple", "banana", "cherry"]) print(choice…

import re

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
import re import re is a Python import that provides regular expression matching. Use it to search, match, replace, or split strings based on patterns. Example # Python # description: regex matching, substitution, splitting import re text = "Contact: alice@example.com or bob@test.org" # Find all email addresses emails = re.findall(r"\b[a-z]+@[a-z.]+\b", text) print(emails) # ['alice@example.com', 'bob@test.org'] # Check if pattern matches if re.search(r"@example\.com", text): print(…

import shutil

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
import shutil import shutil is a Python import that provides high-level file operations: copying, moving, removing directory trees, and archiving files. Example # Python # description: copy files, remove directories, create archives import shutil import os # Copy file shutil.copy("source.txt", "destination.txt") # Copy file with metadata shutil.copy2("source.txt", "destination.txt") # Copy entire directory tree shutil.copytree("src_dir", "dst_dir") # Move file or directory shutil.move("…

import subprocess

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
import subprocess import subprocess is a Python import that runs external programs and captures their output. Use subprocess.run() to execute commands from Python. Example # Python # description: run external commands, capture output import subprocess # Run command and capture output result = subprocess.run(["ls", "-la"], capture_output=True, text=True) print(result.stdout) print(f"Exit code: {result.returncode}") # Run with input/output pipes result = subprocess.run(["grep", "error"], in…

import sys

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
import sys import sys is a Python import that provides access to interpreter state and command-line arguments: argv, exit(), stdin/stdout, and module paths. Use this for CLI scripts that need to read arguments or exit with a status code. Example # Python # description: read command-line arguments, print to stderr import sys # Access command-line arguments (argv[0] is script name) if len(sys.argv) < 2: print("Usage: script.py ", file=sys.stderr) sys.exit(1) name = sys.argv[1]…

import tempfile

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
import tempfile import tempfile is a Python import that creates temporary files and directories. Use it for safe temporary storage that's automatically cleaned up. Example # Python # description: create temporary files and directories import tempfile import os # Temporary file (deleted when closed) with tempfile.NamedTemporaryFile(mode="w", delete=False) as f: f.write("temporary data") temp_path = f.name print(f"Temp file: {temp_path}") os.remove(temp_path) # Temporary directory …

import threading

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
import threading import threading is a Python import that creates and manages threads for concurrent execution. Use threads to run multiple tasks simultaneously in a single process. Example # Python # description: create and run threads import threading import time def worker(name, delay): time.sleep(delay) print(f"Worker {name} done") # Create threads t1 = threading.Thread(target=worker, args=("A", 1)) t2 = threading.Thread(target=worker, args=("B", 2)) # Start threads (runs con…

import time

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
import time import time is a Python import that provides time-related functions: sleeping, measuring elapsed time, and getting the current timestamp. Example # Python # description: sleep, measure elapsed time, get timestamp import time # Current time (seconds since epoch) timestamp = time.time() print(timestamp) # 1724439045.123456 # Sleep for seconds print("Starting...") time.sleep(2) print("Done (2 seconds later)") # Measure elapsed time start = time.time() sum(range(1000000)) elapse…

import traceback

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
import traceback import traceback is a Python import that prints and analyzes exception tracebacks. Use it to log detailed error information without stopping the program. Example # Python # description: print and format exception tracebacks import traceback def risky_function(): data = [1, 2, 3] return data[10] # IndexError try: risky_function() except IndexError: # Print full traceback to stderr traceback.print_exc() # Get traceback as string error_str =…

import typing

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
import typing import typing is a Python import that provides type hints for static type checking. Use type annotations to document function signatures and catch bugs with tools like mypy before runtime. Example # Python # description: type hints for functions and variables from typing import List, Dict, Optional, Union def process_names(names: List[str]) -> int: """Process a list of names and return count.""" return len(names) def find_user(user_id: int) -> Optional[Dict[str, str]…

import unittest

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
import unittest import unittest is a Python import that provides a framework for writing and running unit tests. Use it to test code systematically and catch regressions. Example # Python # description: write and run unit tests import unittest def add(a, b): return a + b class TestMath(unittest.TestCase): def setUp(self): """Called before each test.""" self.result = 0 def test_add_positive(self): self.assertEqual(add(2, 3), 5) def test_add…

import warnings

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
import warnings import warnings is a Python import that issues warning messages. Use it to alert users about deprecated features or suspicious code without raising exceptions. Example # Python # description: issue and filter warnings import warnings # Issue a warning warnings.warn("This feature is deprecated", DeprecationWarning) # Suppress warnings temporarily with warnings.catch_warnings(): warnings.simplefilter("ignore") # Code that issues warnings runs silently warnings.wa…

InfiniBand

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
InfiniBand InfiniBand is a switched-fabric interconnect used across most large HPC and AI training clusters, designed from the start for low latency and RDMA rather than adapted from Ethernet. Host channel adapters support RDMA as a first-class operation, bypassing the kernel entirely and achieving sub-microsecond latencies.

Interconnect

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Interconnect Interconnect is the network fabric connecting compute nodes (or sockets within a node) in a parallel system. It moves data between processors and is characterized by two independent metrics: latency (fixed time to get any message across) and bandwidth (sustained rate of large transfers).

Intro

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Intro Hi, I'm Ivan! This website is my encyclopedia about various technical topics. The topics I cover are mostly related to technology, but sometimes I also write about mathematics and physics. I'm an embedded software engineer, currently pivoting to high-performance engineering (HPC). I like working directly with hardware or low-level software.

Introduction to parallel computing

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Introduction to parallel computing Introduction to parallel computing defines core concepts: parallelism (multiple things executing simultaneously, requiring multiple cores), concurrency (multiple logically independent tasks, on one or many cores),

Introduction to quantum computing

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Introduction to quantum computing Quantum computing is a theory of programming a quantum computer. If you're reading this article, you'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't have a background in physics quantum computing may initially seem math-heavy and rather difficult to understand. An assumption I'm going to make is that the reade…

IonQ

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
IonQ IonQ spun out of research at the University of Maryland and Duke. It builds on Trapped ion qubits, the same core technology as Quantinuum: ytterbium ions held by electromagnetic fields, with gates driven by lasers coupling the ions' internal states to their shared motion in the trap. IonQ keeps its ions in a single linear chain rather than shuttling them between zones, giving natural all-to-all connectivity without Quantinuum's QCCD rearrangement.

iSWAP gate (CUDA-Q)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
iSWAP gate (CUDA-Q) iSWAP gate implementation using CUDA-Q. The example prepares $\lvert 10\rangle$ and applies iSWAP to produce $i\lvert 01\rangle$. // Compile: nvq++ main.cpp -o main // Run: ./main #include struct kernel { __qpu__ void operator()() { cudaq::qvector<2> q; x(q[0]); // q[0]=|1>, q[1]=|0> => |10> iswap(q[0], q[1]); // |10> -> i|01> mz(q); } }; int main() { auto counts = cudaq::sample(kernel{}); counts.du…

iSWAP gate (cuStateVec)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
iSWAP gate (cuStateVec) iSWAP gate implementation using cuStateVec. The example prepares $\lvert 10\rangle$ and applies iSWAP to produce $i\lvert 01\rangle$. // Compile: nvcc main.cu -o main -lcustatevec // Run: ./main #include #include #include int main() { const int nQubits = 2; const int dim = 1 << nQubits; // Prepare |10>: q0=1, q1=0 -> index 2 (binary 10) cuDoubleComplex h_sv[4] = {0}; h_sv[2] = make_cuDoubleComplex(1.0…

iSWAP gate (Qiskit)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
iSWAP gate (Qiskit) iSWAP gate implementation using Qiskit. The example prepares $\lvert 10\rangle$ and applies iSWAP to produce $i\lvert 01\rangle$. from qiskit import QuantumCircuit from qiskit.quantum_info import Statevector qc = QuantumCircuit(2) qc.x(1) # q0=|0>, q1=|1> => |10> in math ordering qc.iswap(0, 1) # |10> -> i|01> print(Statevector(qc)) # Statevector([0.+0.j, 0.+1.j, 0.+0.j, 0.+0.j], dims=(2, 2))

iSWAP gate

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
iSWAP gate iSWAP gate is a two-qubit gate that swaps the $\lvert 01\rangle$ and $\lvert 10\rangle$ amplitudes while multiplying each by $i$, and leaves $\lvert 00\rangle$ and $\lvert 11\rangle$ unchanged. $$\text{iSWAP} = \begin{pmatrix}1&0&0&0\\ 0&0&i&0\\ 0&i&0&0\\ 0&0&0&1\end{pmatrix}$$ $$\text{iSWAP}\lvert 01\rangle = i\lvert 10\rangle \qquad \text{iSWAP}\lvert 10\rangle = i\lvert 01\rangle$$ The factor of $i$ distinguishes iSWAP from the plain SWAP gate. SWAP permutes amplitudes without …

KDP midterm (2026-01-10) question 1

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
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}$

KDP midterm (2026-01-10) question 2

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
KDP midterm (2026-01-10) question 2 Consider a dining table that can seat at most $N$ people ($N > 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

KDP exam (2026-02-18) question 1

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
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 q; bool canEat(int id) { return (phil[(id - 1 + N) % N] != EATING) && (phil[(id + 1)…

KDP exam (2026-02-18) question 2

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
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 < N$$K$

(WIP) KDP exam (2026-02-18) question 3

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
(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.

$\lvert 0 \rangle$ (Zero state)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
$\lvert 0 \rangle$ (Zero state) 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 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}$$I\lvert 0\rangle …

$\lvert 00\rangle$

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
$\lvert 00\rangle$ The state is the two-qubit computational basis state where both qubits are $\lvert 0\rangle$. It is the tensor product $\lvert 0\rangle\otimes\lvert 0\rangle$ — a product state with no entanglement between the qubits. It is the default initial state of every qubit register in a quantum circuit.$$\lvert 00\rangle = \lvert 0\rangle\otimes\lvert 0\rangle = \begin{pmatrix}1\\0\\0\\0\end{pmatrix}$$$\lvert 00\rangle$$0$$H\otimes I$$\lvert 00\rangle$$\lvert 00\rangle$$I_0\lvert 00\…

$\lvert 01\rangle$

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
$\lvert 01\rangle$ The state is a two-qubit computational basis state with qubit 0 in $\lvert 0\rangle$ and qubit 1 in $\lvert 1\rangle$. It is the tensor product $\lvert 0\rangle\otimes\lvert 1\rangle$ — an unentangled product state. It is reached from $\lvert 00\rangle$ by a single $X$ gate on qubit 1. $$\lvert 01\rangle = \lvert 0\rangle\otimes\lvert 1\rangle = \begin{pmatrix}0\\1\\0\\0\end{pmatrix}$$ Measuring qubit 0 yields $0$ with certainty; measuring qubit 1 yields $1$$H\otimes I$$\l…

$\lvert 1\rangle$ (One state)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
$\lvert 1\rangle$ (One state) 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)$$-1$$Z\lvert 1\rangle = -\lvert 1\rangle$$\lvert 1\rangle$$\lvert -\rangle = (\lvert 0\rangle - \lvert 1\rangle)/\sqrt{2…

$\lvert 10\rangle$

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
$\lvert 10\rangle$ The state is a two-qubit computational basis state with qubit 0 in $\lvert 1\rangle$ and qubit 1 in $\lvert 0\rangle$. It is the tensor product $\lvert 1\rangle\otimes\lvert 0\rangle$ — an unentangled product state. It is the SWAP of $\lvert 01\rangle$, reached from $\lvert 00\rangle$ by a single $X$ gate on qubit 0. $$\lvert 10\rangle = \lvert 1\rangle\otimes\lvert 0\rangle = \begin{pmatrix}0\\0\\1\\0\end{pmatrix}$$ Measuring qubit 0 yields $1$$0$$H\otimes I$$\lvert 10\ra…

$\lvert 11\rangle$

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
$\lvert 11\rangle$ The state is the two-qubit computational basis state where both qubits are in $\lvert 1\rangle$. It is the tensor product $\lvert 1\rangle\otimes\lvert 1\rangle$ — an unentangled product state. It is reached from $\lvert 00\rangle$ by $X$ on both qubits, and from $\lvert 10\rangle$ or $\lvert 01\rangle$ by $X$ on the remaining qubit. $$\lvert 11\rangle = \lvert 1\rangle\otimes\lvert 1\rangle = \begin{pmatrix}0\\0\\0\\1\end{pmatrix}$$ Measuring either qubit yields $1$$H\oti…

GHZ state

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
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…

$\lvert -i\rangle$ (Minus-i state)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
$\lvert -i\rangle$ (Minus-i state) The minus-i state $\lvert -i\rangle$ (also written $\lvert -y\rangle$) 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 at coordinates $(0, -1, 0)$. $$\lvert -i\rangle = \frac{1}{\sqrt{2}}(\lvert 0\rangle - i\lvert 1\rangle) = \frac{1}{\sqrt{2}}\begin{pmatrix}1\\-i\end{pmatrix}$$ On the Bloch sphere, $\lvert -i\rangle$…

$\lvert -\rangle$ (Minus state)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
$\lvert -\rangle$ (Minus state) The minus state $\lvert -\rangle$ is an equal superposition of $\lvert 0\rangle$ and $\lvert 1\rangle$ with a relative minus sign. It is one of the six cardinal states on the Bloch sphere, sitting at the negative $x$-axis at coordinates $(-1, 0, 0)$. $$\lvert -\rangle = \frac{1}{\sqrt{2}}(\lvert 0\rangle - \lvert 1\rangle) = \frac{1}{\sqrt{2}}\begin{pmatrix}1\\-1\end{pmatrix}$$ On the Bloch sphere, $\lvert -\rangle$ is an eigenstate of the Pauli-X gate with eig…

$\lvert\Phi^-\rangle$ (Phi-minus state)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
$\lvert\Phi^-\rangle$ (Phi-minus state) The phi-minus state $\lvert\Phi^-\rangle$ is one of the four Bell states — the maximally entangled two-qubit states. It is an equal superposition of $\lvert 00\rangle$ and $\lvert 11\rangle$ with a relative minus sign. Like $\lvert\Phi^+\rangle$, both qubits always give the same outcome in the computational basis; the minus sign is only visible in phase-sensitive measurements.$$\lvert\Phi^-\rangle = \frac{1}{\sqrt{2}}(\lvert 00\rangle - \lvert 11\rangle) …

$\lvert\Phi^+\rangle$ (Phi-plus state)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
$\lvert\Phi^+\rangle$ (Phi-plus state) The phi-plus state $\lvert\Phi^+\rangle$ is one of the four Bell states — the maximally entangled two-qubit states. It is an equal superposition of $\lvert 00\rangle$ and $\lvert 11\rangle$ with the same sign, meaning both qubits are always found in the same state when measured in the computational basis. The other $\Phi$$$\lvert\Phi^+\rangle = \frac{1}{\sqrt{2}}(\lvert 00\rangle + \lvert 11\rangle) = \frac{1}{\sqrt{2}}\begin{pmatrix}1\\0\\0\\1\end{pmatrix…

$\lvert +i\rangle$ (Plus-i state)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
$\lvert +i\rangle$ (Plus-i state) The plus-i state $\lvert +i\rangle$ (also written $\lvert i\rangle$ or $\lvert y\rangle$) 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 at coordinates $(0, 1, 0)$. $$\lvert +i\rangle = \frac{1}{\sqrt{2}}(\lvert 0\rangle + i\lvert 1\rangle) = \frac{1}{\sqrt{2}}\begin{pmatrix}1\\i\end{pmatrix}$$ On the Bloch sphere, $\…

$\lvert +\rangle$ (Plus state)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
$\lvert +\rangle$ (Plus state) The plus state $\lvert +\rangle$ is an equal superposition of $\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 at coordinates $(1, 0, 0)$. $$\lvert +\rangle = \frac{1}{\sqrt{2}}(\lvert 0\rangle + \lvert 1\rangle) = \frac{1}{\sqrt{2}}\begin{pmatrix}1\\1\end{pmatrix}$$ On the Bloch sphere, $\lvert +\rangle$ is an eigenstate of the Pauli-X gate with eig…

$\lvert\Psi^-\rangle$ (Psi-minus state)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
$\lvert\Psi^-\rangle$ (Psi-minus state) The psi-minus state $\lvert\Psi^-\rangle$ is one of the four Bell states — the maximally entangled two-qubit states. It is the only antisymmetric Bell state: swapping the two qubits picks up a minus sign, $\text{SWAP}\lvert\Psi^-\rangle = -\lvert\Psi^-\rangle$. It is also called the singlet state$\Psi$$$\lvert\Psi^-\rangle = \frac{1}{\sqrt{2}}(\lvert 01\rangle - \lvert 10\rangle) = \frac{1}{\sqrt{2}}\begin{pmatrix}0\\1\\-1\\0\end{pmatrix}$$$\lvert\Psi^+\r…

$\lvert\Psi^+\rangle$ (Psi-plus state)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
$\lvert\Psi^+\rangle$ (Psi-plus state) The psi-plus state $\lvert\Psi^+\rangle$ is one of the four Bell states — the maximally entangled two-qubit states. It is an equal superposition of $\lvert 01\rangle$ and $\lvert 10\rangle$ with the same sign, meaning the two qubits always give opposite outcomes when measured in the computational basis. The other $\Psi$$$\lvert\Psi^+\rangle = \frac{1}{\sqrt{2}}(\lvert 01\rangle + \lvert 10\rangle) = \frac{1}{\sqrt{2}}\begin{pmatrix}0\\1\\1\\0\end{pmatrix}$…

W state

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
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 = \…

kpsewhich

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
kpsewhich kpsewhich is a LaTeX-related command. It's a diagnostic command that'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.

Kraus operator

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
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$$K_k$$\mathcal{E}(\rho)$$1-p$$p$$X$$\lvert 0\rangle \leftrightarrow \lvert 1\rangle$$$K…

L1 cache

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
L1 cache L1 cache is the first and fastest level of the cache hierarchy, sitting directly next to a single core with latency of 4-5 cycles. It is intentionally small (typically 32–64 KB) to maintain low latency and is almost always split into separate instruction (L1i) and data (L1d) caches to allow simultaneous instruction fetch and data access.

L2 cache

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
L2 cache L2 cache sits between the fast L1 cache and the large shared L3 cache, typically 256 KB–2 MB per core on modern x86 designs. It is unified (holding both instructions and data) and usually private per core, servicing memory requests in tens of cycles.

L3 cache

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
L3 cache L3 cache is the last level of on-chip cache before DRAM, typically tens of megabytes on server chips. It is shared across all cores on a chip and much slower than L1/L2 but still orders of magnitude faster than DRAM. On many-core designs, L3 is divided into per-core slices connected by an on-chip mesh or ring interconnect.

Landauer's principle

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Landauer's principle Landauer'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$$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{eV}$$

LaTeX syntax

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
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$$

TexLive

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
TexLive TexLive is a LaTeX distribution for scientific and technical typesetting. Write markup in .tex files, compile to PDF with pdflatex or xelatex. Professional alternative to Word for papers, theses, and technical documentation—version-controllable, mathematically precise, cross-platform.

Lindbald master equation

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
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)$$

Lindblad equation (QuTiP)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Lindblad equation (QuTiP) Lindblad equation implementation using QuTiP. QuTiP's mesolve() integrates the full Lindblad master equation when the c_ops list is non-empty: $$\frac{\mathrm{d}\rho}{\mathrm{d}t} = -\frac{i}{\hbar}[H,\,\rho] + \sum_k\!\left(L_k\rho L_k^\dagger - \frac{1}{2}\{L_k^\dagger L_k,\,\rho\}\right)$$ Each element of c_ops is a collapse operator $C_k$; QuTiP constructs the full dissipator term internally as $C_k\rho C_k^\dagger - \frac{1}{2}\{C_k^\dagger C_k, \rho\}$$k$$C_k …

Lindblad equation

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Lindblad equation Lindblad equation (also called the GKSL equation, after Gorini, Kossakowski, Sudarshan, and Lindblad) is the most general Markovian master equation for the density matrix $\rho$ of an open quantum system. It extends the von Neumann equation by adding a dissipator term that models incoherent processes — energy loss, dephasing, and other forms of coupling to an environment.$$\frac{\mathrm{d}\rho}{\mathrm{d}t} = -\frac{i}{\hbar}[H,\,\rho] + \sum_k\!\left(L_k\rho L_k^\dagger - \fr…

Linked list

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Linked list A linked list is a sequence of nodes where each node holds a value and a pointer to the next node. The nodes need not be contiguous in memory; the pointer is what links them. The head pointer is the entry point; the last node's next pointer is NULL. Insertion and deletion at any position where you already hold a pointer costs O(1) — no elements shift — but reaching a position by index requires traversing from the head, costing O(n).

List of algorithms

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
List of algorithms * tree-algorithms * list-of-sorting-algorithms * selection-sort * dijkstra-algorithm

List of articles

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
List of articles * List of tools * List of paths * List of commands * List of hardware * List of C headers * List of C concepts * List of C++ headers * List of C++ concepts * List of embedded engineering concepts * List of parallel computing concepts * List of quantum computing concepts * List of software engineering concepts * List of data structures * List of algorithms * List of miscellaneous topics * List of writing guides

List of C concepts

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T11:41:16+00:00
List of C concepts * C do-while-0 * C duff's device * C X macros * C variadic macros * C function pointers * C bit fields * C flexible array members * C memory alignment * C type punning * C restrict qualifier * C volatile qualifier * C designated initializers * C compound literals * C token pasting * C weak symbols * C static assertions * C VLA * C pragma directives * C function attributes * C tail call optimization * C goto error handling

List of C headers

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
List of C headers * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

List of commands

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
List of commands * List of util-linux commands * List of latex commands * List of system commands * List of HPC commands

List of concepts in quantum control

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
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

List of concepts in quantum error correction

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
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

List of concepts

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
List of concepts * C * header-guards * C pragma once * C++ * C++ name mangling * rule-of-5 * Miscellaneous * Numbers every programmer should know

List of C++ concepts

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
List of C++ concepts * C++ ADL * C++ concepts * C++ const correctness * C++ constexpr * C++ copy-and-SWAP * C++ copy elision * C++ CRTP * C++ dependent names * C++ empty base optimization * C++ erase-remove * C++ evaluation order * C++ exception safety * C++ forwarding references * C++ inline keyword * C++ integer promotions * C++ internal linkage * C++ iterator invalidation * C++ lambda captures * C++ logical constness * C++ most vexing parse * C++ move semantics * C++ na…

List of C++ headers

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
List of C++ headers * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * …

List of data structures

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
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+ tree * Hash map * Graph

List of embedded engineering concepts

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
List of embedded engineering concepts * Embedded engineering * List of logic gates * list-of-communication-protocols * rtos * xv6 * riscv * x86-64 * mcu * spi * uart * i2c * gpio * wcet * Harvard architecture

List of essential quantum computing concepts

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
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 gates * 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 *…

List of hardware

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
List of hardware * ThinkPad * Arduino uno R4 WiFi

List of headers in C++

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
List of headers in C++

List of high-performance computing concepts

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
List of high-performance computing concepts * Hardware architectures * Parallelism models * OpenMP * MPI * CUDA * Memory hierarchy * Cache optimization * Vectorization * Profiling * Roofline model * Amdahl's law * Communication patterns * Load balancing * Numerical libraries * Cluster computing * Debugging distributed applications * Performance bottlenecks * Heterogeneous computing

List of HPC commands

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
List of HPC commands * nvcc * cuobjdump * numactl * perf

List of KDP exercises

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
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

List of latex commands

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
List of latex commands * pdflatex * kpsewhich

List of logic gates

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
List of logic gates * and-gate * or-gate * not-gate * nand-gate * nor-gate

List of miscellaneous quantum computing concepts

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
List of miscellaneous quantum computing concepts * schrodinger-picture * heisenberg-picture * interaction-picture * measurement-problem * intepretation-of-quantum-mechanics * copenhagen-interpretation * many-world-interpretation

List of miscellaneous topics

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
List of miscellaneous topics * bytebeat * code-golf

List of optimal quantum control algorithms

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
List of optimal quantum control algorithms * grape * crab * goat

List of parallel computing concepts

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
List of parallel computing concepts * Parallel computing * Introduction to parallel computing * SAXPY * Synchronization primitive * Semaphore * Mutex * Monitor * Linda * CSP * Mailbox * Numbers every programmer should know * Amdahl's law * Gustafson's law * Cache * L1 cache * L2 cache * L3 cache * Cache coherence * Cache snoopy protocols * WTI * MSI * MESI * MOESI * Dragon * Firefly * Cache directory protocols * CUDA * OpenMP * MP…

List of paths

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
List of paths * /bin * /dev * /boot * /etc * /home * /lib * /mnt * /opt * /proc * /root * /sbin * /srv * /tmp * /usr * /var

List of Python concepts

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
List of Python concepts * Python descriptors * Python metaclasses * Python MRO * Python slots * Python namespace * Python ellipsis * Python walrus operator * Python context managers * Python generators * Python weakref * Python asyncio internals * Python ABC * Python protocols * Python single dispatch * Python bytecode * Python import hooks * Python monkey patching * Python dataclass fields * Python LRU cache * Python GIL

List of Python imports

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
List of Python imports * import os * import sys * import pathlib * import collections * import typing * import re * import json * import math * import datetime * import time * import itertools * import functools * import subprocess * import logging * import argparse * import shutil * import io * import contextlib * import dataclasses * import enum * import random * import tempfile * import threading * import traceback * import unittest * import warnings

List of quantum computing concepts

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:34:57+00:00
List of quantum computing concepts * Quantum computing * Quantum state * Born rule * Probability amplitude * Global phase * Hilbert space * Dirac notation * $\mathbb{CP}^1$ * Hopf fibration * Bloch sphere * Qubit * Canonical states * $\lvert 0 \rangle$ (Zero state) * $\lvert 1\rangle$ (One state) * $\lvert +\rangle$ (Plus state) * $\lvert -\rangle$ (Minus state) * $\lvert +i\rangle$ (Plus-i state) * $\lvert -i\rangle$ (Minus-i state) * Two qubi…

List of quantum computing libraries

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
List of quantum computing libraries * Qiskit * q-sharp

List of quantum error correction codes

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
List of quantum error correction codes * repetition-code * shor-code * surface-code

List of quantum gates

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
List of quantum gates * Types of gates * Rotation gates * Pauli gates * clifford-gates * Individual gates * I gate * X gate * Y gate * Z gate * Rx gate * Ry gate * Rz gate * S gate * T gate * Hadamard gate * P gate * Unitary gate * ccnot-gate * Toffoli gate * CX gate (CNOT) * SWAP gate * iSWAP gate

List of quantum states

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
List of quantum states * computational-basis-states * Bell states * $\lvert 0 \rangle$ (Zero state) * $\lvert 1\rangle$ (One state) * ket-2 * $\lvert +\rangle$ (Plus state) * $\lvert -\rangle$ (Minus state) * $\lvert +i\rangle$ (Plus-i state) * $\lvert -i\rangle$ (Minus-i state) * $\lvert 00\rangle$ * $\lvert 01\rangle$ * $\lvert 10\rangle$ * $\lvert 11\rangle$ * dicke-states * cluster-states * graph-states * choi-states * maximally-entangled-states

List of software engineering concepts

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
List of software engineering concepts * Brooks's law * Parkinson's law * Kanban * Extreme programming * Agile * Test-driven development * CI/CD * DevOps * Blue-green deployment * Canary release * Unit test * Regression * Test automation * Kanban * Feature flag * Production * A/B testing * Hotfix * Feature branch * Eating your own dog food * Spike solution * SOLID * Liskov substitution principle * Smart-and-gets-things-done * DevOps * Incremental build model * Prototyp…

List of software engineering tools

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
List of software engineering tools * jira * confluence * ms-teams * harvestapp * notion

List of syntaxes

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
List of syntaxes * c-syntax * hpp-syntax * LaTeX syntax * Wiki syntax

List of system commands

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
List of system commands * ifupdown

List of tools

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
List of tools * Debian gnu/linux * Git * Docker * Shell * Tmux * SSH * Makefile * CMake * Neovim * GDB * Terminal * TexLive * QEMU * GCC * perf * Valgrind * numactl

List of util-linux commands

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
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 or use the --help option to see what each command does.

List of writing guides

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
List of writing guides * General writing guide * Writing guide on quantum computing * Writing guide on parallel computing

Lock contention

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Lock contention Lock contention occurs when multiple threads frequently compete for the same lock, forcing some to wait rather than run. Contention doesn't scale linearly—it grows disproportionately as more threads compete because failed attempts generate cache-coherence traffic and each waiting thread adds synchronization overhead.

Lock convoy

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Lock convoy Lock convoy is a pathological contention pattern where threads serialize behind a lock even though the lock is held only briefly. It occurs when a lock holder is preempted mid-critical-section, forcing all waiters to idle through the rest of that time slice before the holder even resumes. Once threads pile up waiting, the queue sustains itself because arrivals keep pace with drains.

Lock-free queue

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Lock-free queue A mutex-protected queue is the natural starting point for producer-consumer communication between threads. Under light load it works fine, but under high contention the lock becomes a bottleneck: a thread preempted while holding it stalls every other producer and consumer until it is scheduled again. A

Lock

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Lock Lock is a synchronization mechanism that grants exclusive or limited access to a shared resource among threads. Every lock is built from an atomic read-modify-write instruction for claiming ownership and a waiting policy (spin, sleep, or hybrid) for what a thread does if it cannot claim the resource immediately.

Makefile advanced

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Makefile advanced Recursive Make handles multi-directory projects. Each subdirectory has its own Makefile; the top-level Makefile calls them. # Top-level makefile SUBDIRS = src lib test .PHONY: all clean $(SUBDIRS) all: $(SUBDIRS) $(SUBDIRS): $(MAKE) -C $@ clean: for dir in $(SUBDIRS); do \ $(MAKE) -C $$dir clean; \ done

Makefile basics

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Makefile basics Makefile syntax is simple: targets, prerequisites, and recipes. A target is a build product (executable, object file). Prerequisites are the files it depends on. A recipe is the command to build it. target: prerequisite1 prerequisite2 command to build target

Makefile conditionals

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Makefile conditionals Conditional directives allow different behavior based on variables or environment. Common: ifeq, ifneq, ifdef, ifndef. ifeq (equal): ifeq ($(OS), Linux) LDFLAGS = -lrt else LDFLAGS = -framework CoreFoundation endif

Makefile debugging

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Makefile debugging Debugging Makefiles is often about understanding why Make made certain decisions. Use flags, echo commands, and systematic investigation. Dry-run mode (-n): Preview what Make would do without executing: make -n make -n clean

Makefile dependencies

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Makefile dependencies Dependencies tell Make what files a target depends on. When a prerequisite is newer than the target, Make rebuilds. For C programs, headers are implicit dependencies—changing a header should rebuild all .o files that included it.

Makefile functions

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Makefile functions Make functions manipulate strings and lists. Common ones: wildcard, patsubst, subst, filter, foreach. wildcard expands a glob pattern to a list of files: SRCS = $(wildcard *.c) # main.c util.c helper.c OBJS = $(patsubst %.c, %.o, $(SRCS)) # main.o util.o helper.o

Makefile patterns

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Makefile patterns Pattern rules define a generic recipe for a class of targets. Instead of writing a rule for each .o file, write one pattern rule that matches all of them. %.o: %.c gcc -c -o $@ $< The % is a wildcard. This rule matches main.o (from

Makefile performance

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Makefile performance Incremental builds are Make's strength—only rebuild what changed. But slow Makefiles can still hurt productivity. Optimize with parallelization and caching. Parallel builds with -j: make -j4 # run up to 4 recipes in parallel make -j # unlimited parallelism (risky on limited systems)

Makefile phony targets

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Makefile phony targets Phony targets don't produce files—they're commands. Mark them with .PHONY so Make doesn't check for a file with that name. .PHONY: all clean install test all: app app: main.o util.o gcc -o app main.o util.o clean: rm -f *.o app install: app cp app /usr/local/bin/ test: app ./test.sh

Makefile variables

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Makefile variables Variables in Make store strings (compiler names, flags, file lists). Use VAR = value to define, $(VAR) to expand. CC = gcc CFLAGS = -O3 -Wall -g SRCS = main.c util.c helper.c OBJS = main.o util.o helper.o app: $(OBJS) $(CC) $(CFLAGS) -o app $(OBJS)

Makefile

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Makefile Make is a build automation tool that tracks dependencies and rebuilds only what changed. Define targets (build products), prerequisites (source files), and recipes (compile commands). Make avoids expensive recompilation by detecting what's out of date and rebuilding the minimum necessary.

Math books

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Math books *

Mathematical maturity

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
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's take the equation $2\cdot x = 6$$x = 6 / 2$$x = 3$$b = 0$$x = 0$$a = 0$$a = 0$$b = 3$$x$$0 = 3$$a = 0$$b = 0$$x$$0 = 0$$a\neq 0$$x \in\lbrace b / a\rbrace$$a = 0$$b = 0$$x \in (-\infty, +\infty)$$b \neq 0$$x\in\varnothing$$a\cdot…

Matmul

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
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}}$$$ …

Matrix

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Matrix A matrix is a two-dimensional rectangular array of values organised in rows and columns. In C, a matrix is stored as a flat Array in row-major order: all elements of row 0 come first, then row 1, and so on. The element at row i, column j of an M × N$y = Ax$$O(mn)$$C = AB$$O(mnk)$

MESI

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
MESI MESI (Modified/Exclusive/Shared/Invalid) extends MSI with an Exclusive state to optimize the common case of reading a line then writing to it without contention. A line loaded as Exclusive can transition to Modified on write without broadcasting an invalidate, saving a bus transaction.

Michael-Scott queue

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Michael-Scott queue Michael-Scott queue is the standard lock-free MPMC queue (1996), using separate head and tail pointers with a dummy node and a “helping” mechanism where threads help other threads complete stalled tail updates. It provides full multi-producer/multi-consumer safety using only compare-and-swap.

Microsoft quantum

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Microsoft quantum Microsoft Quantum is pursuing Topological qubits, a different bet from the transmon and trapped-ion approaches used elsewhere. Information is encoded in the braiding of Majorana zero modes, quasiparticles predicted to emerge at the ends of specially engineered superconductor-semiconductor nanowires. Because the information sits in a global topological property rather than a local physical state, the qubit should resist local noise far better than other platforms.

$\lvert -i\rangle$ (Qiskit)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
$\lvert -i\rangle$ (Qiskit) Minus-i state $\lvert -i\rangle$ implementation using Qiskit. The $\lvert -i\rangle$ state is prepared by applying a Hadamard gate followed by an $S^\dagger$ gate to $\lvert 0\rangle$. from qiskit import QuantumCircuit from qiskit.quantum_info import Statevector qc = QuantumCircuit(1) qc.h(0) # |0> -> |+> qc.sdg(0) # |+> -> |-i> = (|0> - i|1>) / sqrt(2) print(Statevector(qc)) # Statevector([0.70710678+0.j, 0.-0.70710678j], dims=(2,))

$\lvert -\rangle$ (Qiskit)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
$\lvert -\rangle$ (Qiskit) Minus state $\lvert -\rangle$ implementation using Qiskit. The $\lvert -\rangle$ state is prepared by applying an X gate followed by a Hadamard gate to $\lvert 0\rangle$. from qiskit import QuantumCircuit from qiskit.quantum_info import Statevector qc = QuantumCircuit(1) qc.x(0) # |0> -> |1> qc.h(0) # |1> -> |-> = (|0> - |1>) / sqrt(2) print(Statevector(qc)) # Statevector([ 0.70710678+0.j, -0.70710678+0.j], dims=(2,))

Mixed state

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
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 = \…

MOESI

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
MOESI MOESI (Modified/Owned/Exclusive/Shared/Invalid) extends MESI with an Owned state to avoid unnecessary write-backs to memory when a dirty line is shared. The Owned state lets dirty data circulate cache-to-cache while only one designated owner is responsible for eventual write-back to memory.

MPI blocking and non-blocking

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
MPI blocking and non-blocking Blocking and non-blocking communication in MPI: MPI_Send and MPI_Recv block until complete. MPI_Isend and MPI_Irecv return immediately with a request handle; MPI_Wait blocks later. MPI_Request req; int x = 42; MPI_Isend(&x, 1, MPI_INT, 1, 0, MPI_COMM_WORLD, &req); do_other_work(); // overlap computation with communication MPI_Wait(&req, MPI_STATUS_IGNORE); // x must not change before this point

MPI collectives

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
MPI collectives Collectives are operations where all processes participate: distributing input, combining results, or synchronizing. They optimize what would be verbose point-to-point code. if (rank == 0) for (int i = 1; i < size; i++) MPI_Send(&x, 1, MPI_INT, i, 0, MPI_COMM_WORLD); else MPI_Recv(&x, 1, MPI_INT, 0, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);

MPI communicator duplication

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
MPI communicator duplication Communicator duplication prevents libraries from intercepting application messages. MPI_Comm_dup creates a new communicator with its own tag namespace. MPI_Comm lib_comm; MPI_Comm_dup(MPI_COMM_WORLD, &lib_comm); library_init(lib_comm); // all internal library traffic uses lib_comm // ... MPI_Comm_free(&lib_comm);

MPI communicators

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
MPI communicators Communicators are groups of processes in MPI. Messages sent on one communicator cannot be received on another, even between the same ranks with the same tag. MPI_COMM_WORLD is the default, including all processes launched by mpirun

MPI deadlock

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
MPI deadlock Deadlock occurs when process 0 sends to process 1 while process 1 sends to process 0 simultaneously; both block waiting for a receive that never comes. // deadlock: both processes block on MPI_Send waiting for the other to MPI_Recv MPI_Send(buf, N, MPI_DOUBLE, peer, 0, MPI_COMM_WORLD); MPI_Recv(buf, N, MPI_DOUBLE, peer, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);

MPI derived datatypes

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
MPI derived datatypes Derived datatypes describe scattered data (matrix columns, alternating elements, struct fields) so MPI can send them directly without manual packing. double tmp[N_ROWS]; for (int i = 0; i < N_ROWS; i++) tmp[i] = matrix[i][col]; MPI_Send(tmp, N_ROWS, MPI_DOUBLE, dest, 0, MPI_COMM_WORLD);

MPI hybrid mpi+openmp

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
MPI hybrid mpi+openmp Hybrid MPI+OpenMP combines MPI for inter-node communication with OpenMP for intra-node parallelism. One MPI rank per node with OpenMP threads is the dominant HPC model. When threads are involved, MPI must be initialised with MPI_Init_thread

MPI message ordering

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
MPI message ordering Message ordering in MPI guarantees FIFO delivery: messages from A to B on the same communicator and tag arrive in order. // rank 1 is guaranteed to receive 1 first, then 2 if (rank == 0) { MPI_Send(&one, 1, MPI_INT, 1, 0, MPI_COMM_WORLD); MPI_Send(&two, 1, MPI_INT, 1, 0, MPI_COMM_WORLD); } else if (rank == 1) { int a, b; MPI_Recv(&a, 1, MPI_INT, 0, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE); // a == 1 MPI_Recv(&b, 1, MPI_INT, 0, 0, MPI_COMM_WORLD, MPI_STAT…

MPI non-blocking collectives

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
MPI non-blocking collectives Non-blocking collectives return immediately with a request handle instead of blocking. Variants like MPI_Ibcast, MPI_Ireduce, MPI_Iallreduce, and MPI_Iscatter let computing overlap with communication. double local = compute_first_part(); double global; MPI_Request req; MPI_Iallreduce(&local, &global, 1, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD, &req); do_independent_work(); MPI_Wait(&req, MPI_STATUS_IGNORE); use(global);

MPI one-sided communication

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
MPI one-sided communication One-sided communication (RMA) lets processes access remote memory directly. MPI_Win_create exposes a window; other processes read with MPI_Get or write with MPI_Put. int val = (rank == 0) ? 42 : 0; MPI_Win win; MPI_Win_create(&val, sizeof(int), sizeof(int), MPI_INFO_NULL, MPI_COMM_WORLD, &win); MPI_Win_fence(0, win); if (rank == 1) MPI_Get(&val, 1, MPI_INT, 0, 0, 1, MPI_INT, win); // rank 1 reads rank 0's val MPI_Win_fence(0, win); // val on rank 1 is now 42…

MPI reference

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
MPI reference Quick reference for MPI functions, datatypes, and reduction operators. Functions // Initialisation MPI_Init(&argc, &argv) // initialise MPI; must be first MPI_Finalize() // shut down MPI; must be last MPI_Abort(comm, errorcode) // terminate all processes in comm // Communicator queries MPI_Comm_rank(comm, &rank) // rank of calling process in comm MPI_Comm_siz…

MPI parallel I/O

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
MPI parallel I/O Parallel I/O lets multiple processes write to the same file with explicit offsets. MPI_File_open and MPI_File_write_at_all coordinate without file position races. MPI_File fh; MPI_File_open(MPI_COMM_WORLD, "output.bin", MPI_MODE_CREATE | MPI_MODE_WRONLY, MPI_INFO_NULL, &fh); MPI_Offset offset = (MPI_Offset)rank * N * sizeof(double); MPI_File_write_at_all(fh, offset, local_data, N, MPI_DOUBLE, MPI_STATUS_IGNORE); MPI_File_close(&fh);

MPI performance model

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
MPI performance model Performance model for MPI is $\alpha + \beta n$, where $\alpha$ is per-message latency and $\beta$ is per-byte time. Latency dominates small messages; bandwidth dominates large ones. Fewer larger messages are faster than many small ones. // bad: N messages, each paying alpha for (int i = 0; i < N; i++) MPI_Send(&vals[i], 1, MPI_DOUBLE, dest, 0, MPI_COMM_WORLD); // good: one message, alpha paid once MPI_Send(vals, N, MPI_DOUBLE, dest, 0, MPI_COMM_WORLD);

MPI persistent communication

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
MPI persistent communication Persistent communication registers a pattern once with MPI_Send_init and MPI_Recv_init, then reuses it with MPI_Start/MPI_Wait. Amortises setup cost for repeated communication. MPI_Request reqs[2]; MPI_Send_init(send_buf, N, MPI_DOUBLE, right, 0, MPI_COMM_WORLD, &reqs[0]); MPI_Recv_init(recv_buf, N, MPI_DOUBLE, left, 0, MPI_COMM_WORLD, &reqs[1]); for (int iter = 0; iter < MAX_ITER; iter++) { pack_halo(send_buf); MPI_Startall(2, reqs); compute_interio…

MPI point-to-point communication

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
MPI point-to-point communication Point-to-point communication sends messages between two processes. MPI_Send transmits a buffer to a target rank; MPI_Recv receives from a source rank. Both specify buffer, element count, datatype, peer rank, message tag, and communicator.

MPI prefix reductions

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
MPI prefix reductions Prefix reductions (scan) in MPI turn an array of N values into N partial results, where each output element is the reduction of all input elements up to that index, like this sequential exclusive prefix sum: int offsets[N]; offsets[0] = 0; for (int i = 1; i < N; i++) offsets[i] = offsets[i-1] + counts[i-1];

MPI probing for messages

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
MPI probing for messages Probing checks for incoming messages without consuming them. MPI_Probe returns metadata in MPI_Status (including element count) so you can allocate the right buffer before calling MPI_Recv. MPI_Status status; MPI_Probe(src, tag, MPI_COMM_WORLD, &status); int count; MPI_Get_count(&status, MPI_DOUBLE, &count); double *buf = malloc(count * sizeof(double)); MPI_Recv(buf, count, MPI_DOUBLE, src, tag, MPI_COMM_WORLD, MPI_STATUS_IGNORE);

MPI process groups

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
MPI process groups Process groups form subsets with explicit rank lists. MPI_Group_incl builds from a list; MPI_Group_excl excludes. MPI_Group world_group, sub_group; MPI_Comm sub_comm; MPI_Comm_group(MPI_COMM_WORLD, &world_group); int ranks[] = {0, 2, 4}; MPI_Group_incl(world_group, 3, ranks, &sub_group); MPI_Comm_create(MPI_COMM_WORLD, sub_group, &sub_comm); if (sub_comm != MPI_COMM_NULL) { // ranks 0, 2, 4 enter here with new ranks 0, 1, 2 in sub_comm do_work(sub_comm); MPI_C…

MPI reduction

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
MPI reduction Reduction in MPI combines all elements of a collection into a single value using an associative operator, just as sequential C does with a loop: double sum = 0.0; for (int i = 0; i < N; i++) sum += arr[i]; In a parallel program, each process holds a different slice of the data and computes a partial result. To get the global value, those partial results need to be combined.

MPI scatter and gather

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
MPI scatter and gather Scatter distributes data from rank 0 to all processes; gather collects from all back to rank 0. Both split work efficiently instead of using loops. if (rank == 0) for (int i = 0; i < size; i++) MPI_Send(&data[i * chunk], chunk, MPI_INT, i, 0, MPI_COMM_WORLD); else MPI_Recv(local, chunk, MPI_INT, 0, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);

MPI send modes

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
MPI send modes Send modes in MPI make blocking behaviour explicit. Standard MPI_Send may block depending on message size; MPI_Ssend always synchronizes, MPI_Bsend always buffers, and MPI_Rsend requires a posted receive. MPI_Ssend (synchronous send) never buffers. It blocks until the receiver has posted a matching

MPI shared memory windows

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
MPI shared memory windows Shared memory windows let processes on the same node access shared memory directly. MPI_Win_allocate_shared allocates a region visible to all processes, avoiding message overhead. MPI_Win win; double *local_ptr; MPI_Win_allocate_shared(N * sizeof(double), sizeof(double), MPI_INFO_NULL, MPI_COMM_WORLD, &local_ptr, &win); // get a pointer directly into another process's segment MPI_Aint seg_size; int disp_unit; double *remote_ptr; MPI_Win_share…

MPI time measurement

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
MPI time measurement Time measurement uses MPI_Wtime() for wall-clock time. Reduce with MPI_MAX across all processes to get the true elapsed time (set by the slowest). MPI_Barrier(MPI_COMM_WORLD); // align all processes before starting the clock double t0 = MPI_Wtime(); do_work(); double elapsed = MPI_Wtime() - t0; double max_elapsed; MPI_Reduce(&elapsed, &max_elapsed, 1, MPI_DOUBLE, MPI_MAX, 0, MPI_COMM_WORLD); if (rank == 0) printf("%.6f s (timer resolution: %.2e s)\n", max_elapse…

MPI virtual topologies

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
MPI virtual topologies Virtual topologies register grid structures so MPI_Cart_shift computes neighbor ranks instead of requiring manual arithmetic. int row = rank / Q, col = rank % Q; int north = ((row - 1 + P) % P) * Q + col; int south = ((row + 1) % P) * Q + col;

MPI

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
MPI MPI (Message Passing Interface) is a standard for distributed-memory parallel programming in C, C++, and Fortran. Launch N independent copies of your program via mpirun -n N ./program; each gets its own address space and communicates by explicitly sending and receiving messages. Unlike

MSI

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
MSI MSI (Modified/Shared/Invalid) is the baseline write-back snoopy coherence protocol. A core can write to a line and keep the new value only in its own cache, deferring write-back to memory until the line is evicted or another core needs it, reducing memory traffic compared to WTI.

Multiqubit gates

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Multiqubit gates Multiqubit gates are quantum gates that act on two or more qubits simultaneously. They are the mechanism by which entanglement is created and destroyed in a quantum circuit — a single-qubit gate acting on one qubit at a time can never entangle two qubits that started in a product state.$2 \times 2$$4 \times 4$$8 \times 8$$n$$2^n \times 2^n$$U$$U$$\lvert 1\rangle$$X$$X$$U$$CU$$4 \times 4$$\lvert 0\rangle$$U$$\lvert 1\rangle$$n$$\{H, T, \text{CX}\}$$\epsilon$$O(\log^c(1/\epsilon)…

My bookmarks

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
My bookmarks C++ * * LaTeX Online tools: * * * Documentation PDFs: * * * Wikipedia Related to mathematics: *

Neovim basics

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
Neovim basics Neovim is a modal text editor: different modes for different tasks. Start in normal mode (commands), press i to enter insert mode (type text), press Esc to return to normal mode. $ nvim file.txt # open file $ nvim +10 file.txt # open file, jump to line 10 $ nvim +/pattern file.txt # open file, search for pattern $ nvim -c "command" file.txt # open file, run ex command

Neovim buffers, windows, and tabs

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Neovim buffers, windows, and tabs Buffers are files loaded in memory. Windows are views onto buffers (you can split windows). Tabs are collections of windows. Understanding the three is key to managing large projects. Buffers :e file — open file in buffer (or create if new).

Neovim configuration

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
Neovim configuration Neovim configuration lives in ~/.config/nvim/init.lua (Lua) or init.vim (Vimscript). Modern Neovim defaults to Lua, which is more powerful and readable than Vimscript. Setup directory structure ~/.config/nvim/ ├── init.lua # main config file ├── lua/ │ └── user/ │ ├── settings.lua # options │ └── keymaps.lua # keybindings └── after/ └── ftplugin/ └── python.lua # file-type specific…

Neovim editing

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Neovim editing Text insertion and deletion are the core of editing in Neovim. Most operations combine a verb (operator) with a subject (motion or text object). Insert modes i — insert before cursor, a — insert after cursor. I — insert at line start (first non-blank),

Neovim keybindings

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
Neovim keybindings Custom keybindings in ~/.config/nvim/init.lua let you personalize Neovim. Use vim.keymap.set() to define them. Basic syntax vim.keymap.set(mode, lhs, rhs, options) * mode: 'n' (normal), 'i' (insert), 'v' (visual), 'c' (command),

Neovim LSP (language server protocol)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
Neovim LSP (language server protocol) Language servers provide IDE features: autocomplete, diagnostics (error highlighting), go-to-definition, rename, hover docs. Neovim has a built-in LSP client; you install language servers separately. Architecture

Neovim lua scripting

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Neovim lua scripting Lua is Neovim's embedded scripting language. Instead of just configuration, you can write plugins and automate complex behavior in Lua. Neovim's API is accessible via the vim module. The vim module Access vim from Lua: -- Options vim.opt.number = true vim.opt.shiftwidth = 4 -- Get option value local num = vim.opt.number:get() -- Commands vim.cmd("echo 'hello'") vim.cmd.vsplit("file.txt") -- fancy syntax -- Keybindings vim.keymap.set('n', 'gd', vim.lsp.buf.definition…

Neovim macros and automation

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Neovim macros and automation Macros are recorded sequences of keystrokes. Record once, replay many times to automate repetitive edits. Recording and playback q + letter — start recording macro (e.g., qa records to register 'a'). Keystrokes are captured. Press

Neovim modes

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Neovim modes Neovim has several modes, each with different key behavior. Master the mode system to edit efficiently. Normal mode — default, for commands. Cursor is a block. Enter from any mode by pressing Esc. Commands move, delete, copy, change. Most time is spent here.

Neovim navigation

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Neovim navigation Movement in Neovim is central to efficiency. Use dedicated keys instead of arrow keys (though they work) — they keep your hands near the home row. Character and word movement h, j, k, l — move left, down, up, right. Alternatives: arrow keys work but are slower.

Neovim operators and motions

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Neovim operators and motions The operator-motion paradigm is central to Vim/Neovim efficiency. An operator is a verb (what to do), and a motion is the subject (where to do it). Combine them: operator + motion = command. Operators d — delete, y — yank (copy),

Neovim plugins

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
Neovim plugins Neovim plugins extend the editor with new features: syntax highlighting, fuzzy search, git integration, language servers, autocomplete. The plugin ecosystem is large and powerful. Plugin managers A plugin manager downloads and manages plugins. Popular managers:

Neovim registers and copy/paste

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Neovim registers and copy/paste Registers are storage slots for text. Neovim has multiple registers; by default, deleted or copied text goes to the unnamed register " (reachable as "" or just omitted). Basic copy and paste y — yank (copy) text to register.

Neovim searching and replacing

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Neovim searching and replacing Search and replace are fundamental for editing large files and maintaining consistency. Neovim uses standard regex patterns. Basic search /pattern — search forward, ?pattern — search backward. Type pattern, press

Neovim

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Neovim Neovim is a modal text editor forked from Vim, built to be extensible and embeddable. Modal editing: the keyboard behaves differently depending on mode—normal mode keys are commands (move, delete, change), insert mode keys are literal text. This lets almost every key act as a command without touching the mouse.

Network configuration

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
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)

Neutral Atom qubits

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Neutral Atom qubits Neutral atom qubits encode information in the internal states of individual neutral atoms (commonly rubidium or cesium) trapped in tightly focused laser beams called optical tweezers. Arrays of tweezers can be arranged into arbitrary two- or three-dimensional geometries, which gives this platform unusual flexibility in qubit connectivity compared to the fixed layouts of a chip. Qubit states are typically encoded either in hyperfine ground states or, for two-qubit gates, temp…

NIH syndrome

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
NIH syndrome NIH syndrome stands for “Not invented here” syndrome. It'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 already exist. The commonly given rationale is that you'll probably find the implementation you made easier to understand (you wrote it!) and you'll be able easily make it fit your needs.

NISQ

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
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}$

NOON state

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
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…

NUMA

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
NUMA NUMA (Non-Uniform Memory Access) describes a multi-socket system where each socket has its own local memory attached, but can also reach remote memory on other sockets over an interconnect. Local memory access is faster than remote, and latency grows with hop count and socket distance. This contrasts with UMA (Uniform Memory Access) where all cores see the same latency.

numactl basics

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
numactl basics NUMA (Non-Uniform Memory Access) is the hardware reality of multi-socket systems. Each CPU socket has its own memory controller and DIMMs; a thread on socket 0 accessing memory on socket 1 crosses the inter-socket interconnect and pays extra latency. Modern CPUs mitigate this with caches, but bandwidth-heavy HPC code suffers measurably.

numactl binding

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
numactl binding Binding pins a process to specific NUMA nodes using --cpunodebind and --membind. Together, they guarantee locality: all threads run on one node, all memory allocates from the same node. numactl --cpunodebind=0 --membind=0 ./program # pin to node 0 numactl --cpunodebind=0-1 --membind=0-1 ./program # allow nodes 0 and 1

numactl diagnosing

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
numactl diagnosing numastat reports where a process's memory actually lives on each NUMA node. Use it to verify that bindings are working as intended. numastat -p $(pgrep myprogram) Example output: Per-node process memory usage (in MBs) PID Node 0 Node 1 Total 1234567 1024 512 1536

numactl memory policies

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
numactl memory policies Memory allocation policies control where malloc, new, and page faults allocate memory. --membind is strict; --preferred is flexible; --interleave spreads memory across nodes. --membind (strict binding): numactl --cpunodebind=0 --membind=0 ./app

numactl MPI

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
numactl MPI MPI rank binding assigns each rank to a NUMA node, keeping the rank's threads and memory local. Most important on shared-memory HPC systems where multiple MPI ranks run on the same node. Basic MPI binding: # 2 ranks, each on its own NUMA node mpirun -n 2 numactl --cpunodebind=\$((OMPI_COMM_WORLD_RANK % 2)) \ --membind=\$((OMPI_COMM_WORLD_RANK % 2)) ./app

numactl openmp

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
numactl openmp Combining numactl with OpenMP ensures threads land on intended cores with local memory. OpenMP's affinity mechanism (OMP_PLACES, OMP_PROC_BIND) specifies which threads run on which cores; numactl enforces it system-wide and controls memory allocation.

numactl performance

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
numactl performance NUMA effects vary by workload. A memory-bandwidth-bound HPC code suffers significantly from cross-socket access; a CPU-bound code with small working set might not. Measuring NUMA impact: Run the same workload with and without binding:

numactl CPU pinning

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
numactl CPU pinning --physcpubind pins to specific logical CPUs (numbered 0, 1, 2, ...) rather than entire NUMA nodes. Useful for fine-grained control when combined with thread affinity schemes (OpenMP, MPI). numactl --physcpubind=0-3 --membind=0 ./app # cores 0-3, node 0 memory numactl --physcpubind=0,2,4,6 --membind=0 ./app # specific cores

numactl

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
numactl numactl controls NUMA (Non-Uniform Memory Access) policy on multi-socket machines. Each CPU socket has its own attached memory. Cross-socket memory access is 2x slower than local access. Pin a process to CPU cores and memory on the same NUMA node to maintain locality—critical for HPC performance.

Numbers every programmer should know

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Numbers every programmer should know Numbers every programmer should know is a reference of hardware latencies: L1 cache (1ns), memory (100ns), SSD (1ms), network (10ms). These span orders of magnitude and shape every performance decision in systems design.

NV center qubits

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
NV center qubits NV center qubits use the nitrogen-vacancy defect in diamond, a substitutional nitrogen atom adjacent to a missing carbon atom, as a solid-state spin qubit. The defect's electronic ground state has a spin-1 triplet, and the $m_s = 0$ and $m_s = \pm1$ sublevels form a natural two-level (or three-level) system that can be initialized, manipulated, and read out optically at room temperature. This makes NV centers unusual among qubit platforms: most others require cryogenic temperat…

nvcc

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
nvcc nvcc (or Nvidia C/C++ compiler) is a C++ compiler created by Nvidia that adds CUDA kernel syntax. $ nvcc kernel.cu

OpenMP atomic

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
OpenMP atomic Atomic in OpenMP protects a single read-modify-write operation like count++ without taking a full mutex, mapping to a hardware atomic instruction where available (e.g. lock xadd on x86) and thus much cheaper than `critical`. This fixes the classic race condition where

OpenMP barrier

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
OpenMP barrier Barrier is a synchronisation point where all threads in a team wait until every member has arrived. OpenMP inserts an implicit barrier at the end of every parallel, for, and sections region. All threads wait there until every member of the team has arrived. An explicit

OpenMP collapse

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
OpenMP collapse Collapse is an OpenMP clause that merges multiple perfectly-nested loops into a single flat iteration space before distributing work across threads. When a loop nest has too few outer iterations to keep all threads busy, distributing only the outer loop leaves most threads idle.

OpenMP critical sections

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
OpenMP critical sections Critical sections in OpenMP protect an arbitrary sequence of shared updates with an implicit mutex: only one thread at a time executes the enclosed block, and threads that arrive while another is inside are blocked until it exits. Unlike

OpenMP data sharing

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
OpenMP data sharing Data sharing in OpenMP makes every variable accessed inside a parallel region explicitly either shared (all threads read and write the same location) or private (each thread gets its own copy). The default for variables declared outside the region is

OpenMP false sharing

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
OpenMP false sharing False sharing is a performance problem that occurs when two threads write to different variables that happen to occupy the same cache line. Cache lines are typically 64 bytes wide. The hardware cache-coherence protocol must keep that line consistent across cores, so every write by one thread invalidates the cached copy in the other and forces a round-trip to main memory. The threads are accessing distinct variables and no actual race condition exists, but performance collap…

OpenMP flush

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
OpenMP flush Flush is OpenMP's mechanism for enforcing memory visibility across threads by committing all pending writes to shared memory and invalidating locally cached reads, making the calling thread's view consistent with every other thread. Like C's

OpenMP master

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
OpenMP master Master is an OpenMP directive that restricts execution of a block to thread 0. Unlike `single`, there is no implicit barrier. Other threads skip the block entirely and continue immediately, making it suitable for non-critical side effects like printing progress or updating a log counter where stalling the whole team would be wasteful.

OpenMP nowait

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
OpenMP nowait Nowait is an OpenMP clause that removes the implicit barrier at the end of a work-sharing construct. Threads that finish their portion of the work early proceed to the next statement immediately instead of waiting for stragglers. This is only safe when the subsequent code does not depend on the results of the current construct.

OpenMP overview

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
OpenMP overview Quick reference for OpenMP directives, functions, and environment variables. Directives #pragma omp parallel // fork a team of threads; join at closing brace #pragma omp parallel for // distribute loop iterations across the team #pragma omp parallel for reduction(+:s) // loop with a parallel reduction #pragma omp parallel sections // distribute independent blocks across the team #pragma omp section …

OpenMP parallel loops

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
OpenMP parallel loops Parallel loops in OpenMP parallelise loops over independent iterations by distributing the iteration range across all threads, each thread writing to its own slice of the array. Adding #pragma omp parallel for above the loop enables this pattern, which is the most common in C when each iteration writes to a different output location and doesn't read results that other iterations produce. No synchronisation is needed because the iterations are independent:

OpenMP reduction

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
OpenMP reduction Reduction in OpenMP gives each thread a private copy of an accumulation variable, lets it accumulate locally without contention, then merges all copies at the end of the loop using the specified operator. This fixes the race condition that occurs when naively adding

OpenMP scheduling

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
OpenMP scheduling Scheduling in OpenMP controls how loop iterations are divided among threads. By default, parallel for splits iterations into roughly equal static chunks assigned to threads upfront. This works well when each iteration takes the same time. When iteration cost varies, static assignment leaves some threads idle while others are still running. A loop where some values of

OpenMP sections

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
OpenMP sections Sections is the OpenMP construct for distributing a fixed set of independent code blocks across threads at compile time, without requiring a loop structure. This is useful for distinct operations like compressing a buffer, encrypting a header, and writing a log simultaneously, where each block is wrapped in

OpenMP SIMD

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
OpenMP SIMD SIMD (single instruction, multiple data) allows a modern CPU to add four floats in a single instruction by loading them into a wide register and operating on all four lanes simultaneously, exposed on x86 as SSE/AVX and on ARM as NEON. The compiler attempts to use these instructions automatically (auto-vectorisation), but it can be blocked by pointer aliasing, non-unit strides, or conditionals it cannot prove safe.

OpenMP single

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
OpenMP single Single is an OpenMP directive that runs the enclosed block on exactly one thread, whichever arrives first. All other threads skip the block and wait at an implicit barrier at the end, so the whole team is synchronised before continuing. It is commonly used for initialisation, I/O, and task generation.

OpenMP tasks

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
OpenMP tasks Tasks are the OpenMP mechanism for irregular parallelism. parallel for only handles loops with a known iteration count. For work like recursive algorithms, tree traversals, and producer-consumer patterns, #pragma omp task packages a unit of work that any idle thread in the current team can pick up and execute. Tasks are created inside a

OpenMP thread affinity

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
OpenMP thread affinity Thread affinity pins threads to specific hardware locations to prevent migration and keep threads close to their data, which matters on multi-socket servers where each socket has its own bank of RAM (NUMA, non-uniform memory access) and accessing local memory is fast while crossing the inter-socket interconnect to reach the other socket's RAM costs roughly 2–3× more. By default, the OS is free to migrate threads between cores and sockets, silently moving a thread away fro…

OpenMP time measurement

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
OpenMP time measurement Time measurement in OpenMP is done with omp_get_wtime(), which returns elapsed wall-clock time in seconds as a double. Calling it before and after a parallel region gives the actual time the user waited, which is what matters for speedup measurement. CPU time is not useful here: it sums across all threads and grows with thread count rather than shrinking.

OpenMP

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
OpenMP OpenMP is a shared-memory parallelism API for C, C++, and Fortran. Add a #pragma omp directive before a loop or block to parallelize it across available cores. The compiler handles thread creation and synchronization; if it doesn't support OpenMP, directives are silently ignored and the program runs serially, making debugging easy.

Phase gate (CUDA-Q)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Phase gate (CUDA-Q) Phase gate implementation using CUDA-Q. The example applies $P(\pi/2) = S$ to $\lvert +\rangle$, rotating it to $\lvert i\rangle = \frac{1}{\sqrt{2}}(\lvert 0\rangle + i\lvert 1\rangle)$. // Compile: nvq++ main.cpp -o main // Run: ./main #include #include struct kernel { __qpu__ void operator()() { cudaq::qubit q; h(q); // |0> -> |+> r1(M_PI / 2.0, q); // P(pi/2) = S gate mz(q); } }; …

Phase gate (cuStateVec)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Phase gate (cuStateVec) Phase gate implementation using cuStateVec. The example applies $P(\pi/2) = S$ to $\lvert +\rangle$, rotating it to $\lvert i\rangle = \frac{1}{\sqrt{2}}(\lvert 0\rangle + i\lvert 1\rangle)$. // Compile: nvcc main.cu -o main -lcustatevec // Run: ./main #include #include #include #include int main() { const int nQubits = 1; const int dim = 1 << nQubits; cuDoubleComplex h_sv[2] = {{1,0},{0,0}}; // |0>…

Phase gate (Qiskit)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Phase gate (Qiskit) Phase gate implementation using Qiskit. The example applies $P(\pi/2) = S$ to $\lvert +\rangle$, rotating it to $\lvert i\rangle = \frac{1}{\sqrt{2}}(\lvert 0\rangle + i\lvert 1\rangle)$. from qiskit import QuantumCircuit from qiskit.quantum_info import Statevector import numpy as np qc = QuantumCircuit(1) qc.h(0) # |0> -> |+> qc.p(np.pi / 2, 0) # P(pi/2) = S: |+> -> |i> print(Statevector(qc)) # Statevector([0.70710678+0.j, 0.+0.70710678j], dims=(2,))

P gate

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
P gate Phase gate (or P gate) is a single-qubit gate that applies a phase shift $\phi$ to the $\lvert 1\rvert$ 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 & 0\\ 0 & 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\lvert 0\rang…

Overview

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Overview Paradigms Paradigm Memory model API Typical scale Shared-memory Common address space OpenMP, pthreads Single node Distributed-memory Private per process MPI Multi-node cluster GPU Host + device CUDA, HIP, OpenCL Single GPU Hybrid Mixed $S = \dfrac{1}{s + (1-s)/p}$$s$$p$$S = p - s(p-1)$$p$$\min(\pi,\; I \cdot \beta)$

Parallel computing

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Parallel computing Parallel computing is a computational model where work is broken into parts that execute simultaneously across multiple processors, cores, or machines. Modern CPUs gain performance through additional cores rather than clock speed increases, so exploiting parallelism is essential for performance.

Pasqal

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Pasqal Pasqal is a French company founded out of the Institut d'Optique. It builds on Neutral Atom qubits, the same family as Atom Computing and QuEra Computing, using optical tweezers and Rydberg-state gates. Its atoms are arranged in full 3D configurations rather than flat grids, since tweezers can position atoms anywhere in a volume.

Disclaimer

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Disclaimer This website is not an authoritative source. It is written by one person -- me. It'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

/bin

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
/bin /bin is the directory for essential user-facing command binaries that must be available before any other filesystem is mounted. It contains the tools needed to boot the system, enter single-user mode, and recover from a broken install: sh, ls,

/boot

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
/boot /boot holds the files the bootloader needs to start the kernel: the kernel image itself, the initial RAM disk, and the bootloader configuration. Everything in /boot is read before the root filesystem is fully operational. Once the kernel is running and the system is up, nothing in

/dev

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
/dev /dev is the directory that exposes hardware devices and kernel abstractions as files. Reading and writing a file in /dev communicates directly with a device driver. This is the “everything is a file” principle made concrete: a disk, a terminal, a random number generator, and a null sink all appear as regular file paths that ordinary

/etc

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
/etc /etc holds system-wide configuration files. Every file in /etc is a plain text file or a directory of text files; no binaries live here. Editing a file in /etc changes the behaviour of the corresponding service or subsystem for all users on the machine. User-level configuration lives in dotfiles under

/home

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
/home /home contains the personal directories of non-root users. Each user gets a subdirectory named after their login: /home/alice, /home/bob. The shell sets $HOME to this path at login, and programs use it as the default location for user-specific data and configuration. Dotfiles — files and directories whose names begin with

/lib

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
/lib /lib holds the shared libraries required by the binaries in /bin and /sbin. These are the .so files the dynamic linker loads at runtime. The C standard library (libc.so.6), the dynamic linker itself (ld-linux.so.2), and kernel modules all live here. The constraint is the same as for

/mnt

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
/mnt /mnt is the conventional location for temporarily mounting filesystems by hand. There is no daemon managing it and no automatic population — a sysadmin mounts something here, uses it, and unmounts it. It is a scratch space for one-off mounts: a USB drive being inspected, a disk image being repaired, another OS partition being accessed for recovery.

/opt

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
/opt /opt holds self-contained optional software packages that install outside the normal distribution package manager. Each package gets its own subdirectory, and inside it the layout mirrors the root hierarchy: bin/, lib/, share/, etc/. Nothing in

/proc

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
/proc /proc is a virtual filesystem (procfs) with no backing storage on disk. Every file and directory in it is generated on the fly by the kernel when read. It is the primary interface for reading kernel state and per-process information from userspace, using ordinary

/root

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
/root /root is the home directory of the root user (superuser). It is deliberately separate from /home — placing it directly on the root filesystem means it is available even if the /home partition fails to mount or does not exist. A sysadmin logging in for emergency recovery or single-user mode can always reach

/sbin

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
/sbin /sbin holds system administration binaries: tools used to manage the machine that are typically run as root. The distinction from /bin is intent: /bin contains tools any user might need (ls, cat, cp), while /sbin contains tools for system configuration and maintenance (

/srv

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
/srv /srv holds data that is served to the outside world by services running on this machine. The idea is to give web servers, FTP servers, and similar daemons a dedicated, clearly named location for their content, separate from system configuration in

/tmp

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
/tmp /tmp is the system-wide directory for temporary files. Any process can create files here. The kernel cleans it on reboot; many distributions also run a periodic cleanup of files older than a few days. On most modern systems /tmp is a tmpfs mount, meaning it lives entirely in RAM (and swap) rather than on disk — writes to

/usr

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
/usr /usr is the secondary hierarchy and holds the bulk of the system's installed software. On a fresh install the majority of disk space under / is consumed by /usr. It mirrors the top-level structure: /usr/bin for user binaries, /usr/lib for libraries,

/var

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
/var /var holds variable data: files whose content grows and changes during normal system operation. Log files, mail spools, package manager caches, lock files, and runtime state all live here. Separating this from /usr (which is largely static after install) makes it practical to mount

Pauli gates (CUDA-Q)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Pauli gates (CUDA-Q) Pauli gates implementation using CUDA-Q. // Compile: nvq++ main.cpp -o main // Run: ./main #include struct apply_i { __qpu__ void operator()() { cudaq::qubit q; mz(q); } }; struct apply_x { __qpu__ void operator()() { cudaq::qubit q; x(q); mz(q); } }; struct apply_y { __qpu__ void operator()() { cudaq::qubit q; y(q); mz(q); } }; struct apply_z { __qpu__ void operator()() { cudaq::qubit q; h(q); z(q); h(q); mz(q); } }; int main() { cu…

Pauli gates (cuStateVec)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Pauli gates (cuStateVec) Pauli gates implementation using cuStateVec. // Compile: nvcc main.cu -o main -lcustatevec // Run: ./main #include #include #include #include static void apply_and_print(custatevecHandle_t handle, cuDoubleComplex *d_sv, cuDoubleComplex gate[4], const char *label) { cuDoubleComplex h_sv[2] = {{1,0},{0,0}}; // reset to |0> cudaMemcpy(d_sv, h_sv, 2 * sizeof(cuDoubleComplex), cu…

Pauli gates (Qiskit)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Pauli gates (Qiskit) Pauli gates implementation using Qiskit. from qiskit import QuantumCircuit from qiskit.quantum_info import Statevector qc = QuantumCircuit(4) qc.id(0) # |0> -> |0> qc.x(1) # |0> -> |1> qc.y(2) # |0> -> i|1> qc.h(3) qc.z(3) # |+> -> |-> for i, label in enumerate(['I', 'X', 'Y', 'Z']): sub = QuantumCircuit(1) sub.append(qc.data[i].operation, [0]) if label == 'Z': sub.h(0) sub.z(0) print(f"{label}: {Statevector(sub)}")

Pauli gates

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Pauli gates Pauli gates are the four single-qubit gates $I$, $X$, $Y$, $Z$ corresponding to the identity and the three Pauli matrices. They form the basis of single-qubit quantum operations and appear throughout quantum error correction, where $X$, $Y$, and $Z$ represent the three fundamental error types a qubit can suffer.$$I = \begin{pmatrix}1 & 0\\0 & 1\end{pmatrix}\qquad X = \begin{pmatrix}0 & 1\\ 1 & 0\end{pmatrix}\qquad Y = \begin{pmatrix}0 & -i \\ i & 0\end{pmatrix}\qquad Z = \begin{pmat…

pdflatex

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
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

Quantum computing

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Quantum computing * bra * ket * qudit * State vector * operator * gate * tensor-product * Density matrix * lie-group * lie-algebra * cptp-map * choi-matrix * stinespring-dilation * von-neumann-entropy * ansatz * Bloch sphere * bloch-ball * partial-trace * fubini-study-metric * entangled-state * separable-state * schmidt-rank * schmidt-decomposition * povm

perf annotate

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
perf annotate perf annotate drills down to the instruction level, showing source code or disassembly with per-instruction sample counts. This reveals exactly which line or instruction inside a hot function is causing stalls. perf record -g ./program perf annotate my_hot_function # interactive browser perf annotate --stdio -s my_hot_function # text output

perf basics

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
perf basics perf is a Linux kernel profiling tool that reads hardware performance counters—built-in CPU registers that count events like cycles, instructions, cache misses, and branches. Install it via your package manager and configure permissions to allow non-root profiling.

perf events

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
perf events perf exposes three categories of events: hardware events from the CPU's performance monitoring unit (PMU), software events from the kernel, and tracepoints that instrument specific kernel functions. Hardware events count micro-architectural phenomena:

perf flame graphs

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
perf flame graphs Flame graphs visualize call-graph profiling data as stacked horizontal bars, where bar width represents CPU time spent in each function. Developed by Brendan Gregg, they're ideal for understanding which function call chains consume the most CPU.

perf metrics

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
perf metrics Key performance metrics derived from hardware counters reveal what the CPU is doing and where it's spending time. Instructions per cycle (IPC) is the most important metric—it tells you how efficiently the CPU is using its execution pipeline. Calculate it as

perf record

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
perf record perf record samples the program at a fixed event rate and captures the current instruction pointer and call stack at each sample. This produces a data file (perf.data) that can be analyzed later to see where in the code the CPU was spending time.

perf report

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
perf report perf report analyzes recorded samples from perf.data and shows which functions consumed the most CPU time. It opens an interactive text UI where you can explore call graphs and filter results. perf record -g ./program # record with call graphs perf report # open interactive browser

perf sampling

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
perf sampling Sampling is the core mechanism of perf record. Instead of counting every event (which would be prohibitively expensive), perf samples at a fixed rate and records what was happening at each sample point. This gives statistical profiling with low overhead.

perf scripting

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
perf scripting perf script exports profiling data in a human-readable format, enabling custom analysis and integration with other tools. It's the bridge between perf's binary perf.data and external scripts. perf record ./program perf script # dump all samples as text perf script -i mydata.data # analyze specific file perf script --stdio # explicit non-interactive output

perf stat

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
perf stat perf stat counts hardware events over the full runtime of a program and prints a summary when it exits. It's the fastest way to get a quantitative characterization of CPU behavior without sampling overhead. perf stat ./program perf stat -e cycles,instructions,cache-misses ./program perf stat -e cycles,instructions,cache-misses,L1-dcache-load-misses ./program

perf

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
perf perf is a Linux profiling tool that reads hardware performance counters from the CPU. Measure cycles, instructions, cache misses, branches—everything the CPU tracks natively. Answer the fundamental question: where is the program spending time, and why is it slow?

Phase gates

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Phase gates Phase gates are single-qubit quantum gates that change the relative phase of the $\lvert 1\rangle$ component of a qubit while leaving the $\lvert 0\rangle$ component unchanged. The general phase gate is usually written as $P(\phi)$: $$P(\phi) = \begin{pmatrix}1 & 0\\0 & e^{i\phi}\end{pmatrix}$$ Applied to a qubit in the state $\lvert\psi\rangle = \alpha\lvert0\rangle + \beta\lvert1\rangle$, it produces$$P(\phi)\lvert\psi\rangle = \alpha\lvert0\rangle + e^{i\phi}\beta\lvert1\rangle…

Photonic qubits

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Photonic qubits Photonic qubits encode quantum information in the degrees of freedom of single photons, most commonly polarization, path, or time-bin, and use linear optical elements like beamsplitters and phase shifters to implement gates. Unlike matter-based qubits, photons barely interact with their environment, which makes them nearly immune to decoherence during flight and a natural choice for quantum communication. It also makes them hard to compute with, since two-qubit gates normally ne…

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00

$\lvert +\rangle$ (Qiskit)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
$\lvert +\rangle$ (Qiskit) Plus state $\lvert +\rangle$ implementation using Qiskit. The $\lvert +\rangle$ state is prepared by applying a Hadamard gate to $\lvert 0\rangle$. from qiskit import QuantumCircuit from qiskit.quantum_info import Statevector qc = QuantumCircuit(1) qc.h(0) # |0> -> |+> = (|0> + |1>) / sqrt(2) print(Statevector(qc)) # Statevector([0.70710678+0.j, 0.70710678+0.j], dims=(2,))

POSIX headers

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
POSIX headers POSIX headers are C programming language headers as defined by POSIX. Links *

Probability amplitude

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Probability amplitude Probability amplitude is a complex number associated with a possible outcome of a quantum measurement. The probability of that outcome is the squared modulus of the amplitude, a rule known as the Born rule. Classical probability uses real numbers in $[0, 1]$$\lvert\psi\rangle = a\lvert 0\rangle + b\lvert 1\rangle$$a$$b$$$P_0 = |a|^2 \qquad P_1 = |b|^2$$$$|a|^2 + |b|^2 = 1$$$n$$2^n$$\sum_x |c_x|^2 = 1$$\mathbb{C}^{2^n}$$c_1$$c_2$$|c_1 + c_2|^2$$|c_1|^2 + |c_2|^2$$\lvert 0\…

PsiQuantum

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
PsiQuantum PsiQuantum builds computers on Photonic qubits, encoding information in single photons instead of matter. Photons barely interact with their environment, so they hold onto their quantum state well. That same weak interaction makes it hard to get two photons to interact with each other for a two-qubit gate.

Pure state

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
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…

Python ABC

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
Python ABC Python ABC (Abstract Base Classes) from the abc module let you define classes that can't be instantiated directly and require subclasses to implement specific methods. They enforce interface contracts without the overhead of multiple inheritance, making it clear what methods subclasses must provide.

Python asyncio internals

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
Python asyncio internals Python asyncio internals refer to the event loop and task scheduling that power async/await. The event loop repeatedly polls I/O operations and runs ready coroutines, allowing thousands of concurrent connections with minimal threads. Understanding the event loop helps debug async behavior and write efficient concurrent code.

Python bytecode

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
Python bytecode Python bytecode is the intermediate representation Python compiles source code into before execution. The dis module lets you inspect bytecode instructions, showing exactly what operations Python executes. Understanding bytecode helps you optimize hot paths, debug performance issues, and understand Python's execution model.

Python context managers

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
Python context managers Python context managers are objects that define __enter__ and __exit__ to manage setup and teardown around a with block. They guarantee cleanup runs even if an exception occurs, making them ideal for resource management (files, locks, database connections).

Python dataclass fields

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
Python dataclass fields Python dataclass fields (from the dataclasses module) let you declare class attributes declaratively with type hints, default values, and factories. The field() function customizes how attributes behave: mutable defaults via factories, excluding from

Python descriptors

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Python descriptors Python descriptors are objects that implement __get__, __set__, or __delete__ to intercept attribute access. They power properties, methods, static methods, and class variables—any time you access an attribute on an instance or class, the descriptor protocol may run.

Python ellipsis

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
Python ellipsis Python ellipsis (...) is a literal value representing an undefined, incomplete, or indeterminate result. It's most commonly used as a placeholder in function stubs, but it's a real object with special semantics in slicing, type hints, and protocol definitions.

Python generators

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
Python generators Python generators are functions that use yield to produce a sequence of values lazily, one at a time. Instead of computing all values and returning a list, generators suspend execution at each yield, resuming when the next value is requested. They're memory-efficient for large sequences and enable elegant state machines.

Python GIL

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
Python GIL Python GIL (Global Interpreter Lock) is a mutex that prevents multiple threads from executing Python bytecode simultaneously in CPython. Only one thread can hold the GIL at a time, making CPU-bound multithreading ineffective. The GIL exists because CPython's memory management isn't thread-safe; removing it hurts single-threaded performance.

Python import hooks

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
Python import hooks Python import hooks let you customize how modules are found and loaded. Using sys.meta_path, sys.path_hooks, and the importlib module, you can intercept imports to load from non-standard locations (zip files, URLs, generated code), transform source before execution, or enforce module restrictions.

Python LRU cache

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
Python LRU cache Python LRU cache (from functools.lru_cache) memoizes function results in a fixed-size cache, keeping the most-recently-used items and evicting least-recently-used ones when full. Caching expensive computations (recursive functions, database queries, calculations) can dramatically improve performance—but only for functions with pure (no side effects) logic and hashable arguments.

Python metaclasses

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
Python metaclasses Python metaclasses are classes whose instances are classes. Just as an object is an instance of a class, a class is an instance of its metaclass. By defining a metaclass, you can intercept class creation and control how classes behave.

Python monkey patching

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
Python monkey patching Python monkey patching is modifying modules, classes, or objects at runtime—replacing methods, adding attributes, or changing behavior without modifying source code. While powerful, it's a code smell that trades explicitness for flexibility; use it mainly for testing (with mocking), temporary workarounds, or plugin systems where modification is intended.

Python MRO

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
Python MRO Python MRO (Method Resolution Order) defines the order in which Python looks for a method or attribute in a class hierarchy. With multiple inheritance, determining which parent class's method to call requires a consistent, predictable algorithm—Python uses C3 linearization.

Python namespace

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
Python namespace Python namespace is a mapping from names to objects. Every scope has its own namespace (global, local, built-in), and Python searches them in order using LEGB (Local, Enclosing, Global, Built-in) to find what a name refers to. Understanding scopes prevents variable shadowing bugs and clarifies how closure variables work.

Python protocols

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
Python protocols Python protocols (from typing.Protocol) define structural types—what methods and attributes an object must have, without requiring explicit inheritance. A class conforms to a protocol if it implements the right methods, whether or not it inherits from the protocol class. Protocols enable duck typing with static type checking.

Python single dispatch

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
Python single dispatch Python single dispatch (from functools.singledispatch) provides function overloading based on the type of the first argument. A single function name dispatches to different implementations depending on what type is passed, making type-specific behavior declarative and extensible without large if/elif chains.

Python slots

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
Python slots Python slots restrict which attributes an instance can have by defining __slots__ in a class. Instead of storing attributes in a flexible dictionary, instances with slots use fixed memory for only those attributes, reducing memory overhead and improving attribute access speed.

Python walrus operator

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
Python walrus operator Python walrus operator (:=) is assignment expression syntax that assigns a value and returns it in a single expression. It lets you compute a value once, assign it to a variable, and use that variable—all in one expression, reducing duplication and improving readability in loops and conditionals.

Python weakref

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
Python weakref Python weakref provides references to objects that don't prevent garbage collection. If you hold a weak reference to an object and nothing else references it, the object is freed and the weak reference becomes invalid. Use weak references to break circular references, implement caches that don't keep objects alive, or monitor when objects are deleted.

QAOA

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
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_…

QEMU basics

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
QEMU basics QEMU comes in two variants: system mode for full machine emulation, and user mode for single-binary emulation. Install with apt install qemu-system qemu-user-static on Debian/Ubuntu. qemu-system-arm -M versatilepb -kernel zImage -nographic # full machine qemu-arm ./binary # single binary

QEMU disk images

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
QEMU disk images qemu-img creates and manages virtual disk images for system-mode QEMU. The qcow2 (QEMU Copy-On-Write) format is standard—it's sparse, supports snapshots, and allows multiple VMs to share a base image without duplicating storage. qemu-img create -f qcow2 disk.qcow2 20G # create 20GB image qemu-img create -b base.qcow2 -f qcow2 vm.img # create from snapshot qemu-system-x86_64 -hda disk.qcow2 -m 4G # boot with -hda flag

QEMU disk I/O

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
QEMU disk I/O Disk attachment and I/O backends control how QEMU presents block devices to the guest. -hda is the legacy way; modern QEMU uses -drive for more control. # Legacy (still works) qemu-system-x86_64 -hda disk.qcow2 -hdb cdrom.iso # Modern (preferred) qemu-system-x86_64 -drive file=disk.qcow2,format=qcow2,if=none,id=root \ -device virtio-blk-pci,drive=root # Even simpler (auto format detection) qemu-system-x86_64 -drive file=disk.qcow2

QEMU GDB debugging

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
QEMU GDB debugging QEMU can expose a GDB remote-debugging stub that lets GDB attach to code running inside the emulated machine—kernel, bootloader, firmware—and step through it as if it were a local process. The standard way to debug early boot without a JTAG probe.

QEMU kernel booting

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
QEMU kernel booting Kernel booting is the fastest way to test a freshly cross-compiled kernel without needing a full disk image. Load the kernel, device tree, and command-line arguments directly. qemu-system-arm -M versatilepb -kernel zImage -dtb versatile.dtb \ -append "console=ttyAMA0 earlycon" -nographic

QEMU KVM acceleration

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
QEMU KVM acceleration KVM (Kernel-based Virtual Machine) accelerates QEMU when the guest and host architectures match. QEMU hands off instruction execution to the CPU's hardware virtualization extensions, yielding near-native VM performance instead of the much slower software instruction translation (TCG).

QEMU machine types

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
QEMU machine types Machine type (-M) selects the emulated board, determining CPU architecture, memory map, available peripherals, and which devices are accessible. Different boards have different capabilities. qemu-system-arm -M versatilepb -kernel Image # ARM Versatile PB qemu-system-arm -M virt -kernel Image # Generic virtual machine qemu-system-riscv64 -M virt -kernel Image # RISC-V virtual machine qemu-system-arm -M raspi2 # Raspberry Pi 2 …

QEMU networking

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
QEMU networking QEMU can bridge guest networking to the host via several backends: user-mode networking (simple, no root), tap devices (full performance, requires root), or socket-based for inter-VM communication. # User-mode networking (default, no root needed) qemu-system-x86_64 -nic user,hostfwd=tcp:127.0.0.1:2222-:22 disk.img # Tap device (bridged, full speed, needs root) sudo qemu-system-x86_64 -nic tap,ifname=tap0,script=no disk.img # No networking qemu-system-x86_64 -nic none disk.im…

QEMU serial console

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
QEMU serial console Serial console redirection is the most common way to interact with QEMU VMs running headless. -nographic redirects the emulated serial port to your terminal's stdin/stdout. qemu-system-arm -M versatilepb -kernel zImage -nographic # Kernel output appears on terminal; you can type at the login prompt

QEMU user mode

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
QEMU user mode User mode emulates only a single foreign-architecture binary, translating its syscalls to the host kernel. It's much lighter weight than system mode and useful for testing cross-compiled binaries without booting a full OS. qemu-user-static -b /usr /bin/bash # run bash in ARM environment qemu-arm ./my_cross_compiled_binary # run cross-compiled binary qemu-aarch64 -L /path/to/sysroot ./binary # with custom sysroot

QEMU

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
QEMU QEMU is an emulator and virtualizer. Emulate foreign-architecture binaries (ARM, RISC-V) on x86 to test cross-compiled code without hardware. Or use KVM acceleration to run same-architecture VMs at near-native speed. In embedded work, QEMU boots a cross-compiled kernel or bootloader on x86 to verify it before touching real hardware. In server/VM work, QEMU with KVM runs a guest OS at speeds close to bare metal, delegating instruction execution directly to the CPU.

QFT

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
QFT 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$ qubits. $$\text{QFT}\lvert j\rangle = \frac{1}{\sqrt{N}}\sum_{k=0}^{N-1} e^{2\pi ijk/N}\lvert k\rangle$$ The QFT is implemented in $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{pma…

Ansatz

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Ansatz Ansatz (German for “starting point”) is the family of parameterized quantum circuits used in variational algorithms. The ansatz is the trainable part: you design its structure (which gates, how many layers), and a classical optimizer trains its parameters to minimize a cost function. The quality of a variational algorithm depends entirely on the ansatz: if the true solution is not representable by your ansatz, the algorithm cannot find it, no matter how good the optimizer is.

Backends

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Backends Backends are the execution targets for quantum circuits. A backend can be a classical simulator or a real quantum processor. Qiskit abstracts the details: you design once, then run on different backends without changing code. Each backend has constraints: a gate set (which gates it natively supports), qubit connectivity (which pairs can interact), and error rates.

Circuit optimization

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Circuit optimization Circuit optimization reduces gate count, depth, and two-qubit gate count without changing the circuit's computation. Optimized circuits run faster, accumulate less error on noisy hardware, and consume fewer quantum resources. Qiskit's transpiler includes optimization passes (e.g.,

Error mitigation

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Error mitigation Error mitigation reduces the effect of noise without correcting errors—it trades quantum resources (more circuits) for classical post-processing to improve result accuracy. Unlike error correction (which requires thousands of physical qubits per logical qubit), error mitigation works on current hardware.$$\text{Cost}(\lambda) = A + B e^{-\lambda}$$$\lambda$

IBM quantum platform

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
IBM quantum platform IBM Quantum Platform is a cloud service providing access to real IBM quantum processors. Create a free account, use Qiskit to design circuits, and run them on hardware or high-fidelity simulators. The platform includes calibration data, device status, and job queuing. Qiskit integrates via

Job submission and results

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Job submission and results Job submission sends a circuit (or batch of circuits) to a backend and returns a Job object for tracking. Jobs on remote backends (real hardware, cloud simulators) are queued; results arrive later. Local simulators return results immediately.

Measurement

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Measurement Measurement is the only way to extract information from a quantum circuit. When you measure a qubit in state $\alpha \lvert 0 \rangle + \beta \lvert 1 \rangle$, you get a classical bit: 0 with probability $|\alpha|^2$ or 1 with probability $|\beta|^2$. The measurement collapses the qubit into the observed state and destroys the superposition.$\lvert 0 \rangle / \lvert 1 \rangle$

Noise models

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Noise models Noise models simulate the imperfections of real quantum hardware within a classical simulator. Real qubits have decoherence (information loss over time), gate errors, measurement errors, and crosstalk. Noise models let you study algorithm robustness before running on expensive hardware.$p$

Optimizers

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Optimizers Optimizers are classical algorithms that train ansatz parameters in variational algorithms. Given a cost function $f(\theta)$, an optimizer iteratively updates $\theta$ to minimize $f$. Qiskit provides gradient-free and gradient-based optimizers. Gradient-Free optimizers * COBYLA (Constrained Optimization By Linear Approximation): robust, handles non-smooth landscapes, no gradient required

Parameterized circuits

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Parameterized circuits Parameterized circuits use symbolic parameters instead of fixed rotation angles. Useful for variational algorithms where you optimize parameters iteratively: evaluate the circuit with parameters $\theta_1, \theta_2, \ldots$, compute a cost, adjust parameters, repeat. Instead of rebuilding the circuit each iteration, define parameters once and bind different values—much faster.

Pulse programming

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Pulse programming Pulse programming gives fine-grained control over quantum gates by specifying the microwave pulses sent to qubits. Instead of abstract gates like H or CNOT, you define the exact electromagnetic pulse shape, frequency, and duration.

QAOA (quantum approximate optimization algorithm)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
QAOA (quantum approximate optimization algorithm) QAOA is a variational algorithm for solving combinatorial optimization problems. Given a cost function $C(z)$ (where $z$ is a binary string), QAOA constructs a quantum ansatz that preferentially amplifies high-scoring solutions, then measures to sample solutions.$p$$2p$$e^{-i\gamma H_C}$$H_C$$e^{-i\beta H_M}$$H_M = \sum X_i$$p$$\gamma = [\gamma_1, \ldots, \gamma_p]$$\beta = [\beta_1, \ldots, \beta_p]$$\gamma$$\beta$$p$$p$

OpenQASM

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
OpenQASM OpenQASM (Open Quantum Assembly Language) is a low-level instruction format for quantum circuits. It's a text language that describes qubit operations, gates, measurements, and control flow. Qiskit can convert circuits to OpenQASM and back.

Quantum circuits

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Quantum circuits Quantum circuits are the fundamental way to describe quantum computations in Qiskit—an ordered sequence of operations applied to qubits. A circuit specifies which gates to apply, in what order, on which qubits, and where to measure. Think of it like assembly code: abstract and portable, executable on any backend that supports the required gate set.

Quantum gates

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Quantum gates Quantum gates are unitary operations that transform qubit states. Like classical logic gates (AND, OR, NOT), quantum gates manipulate qubits—but they preserve superposition and enable entanglement. Every quantum gate is reversible (unitary).$\lvert 0 \rangle$$\frac{1}{\sqrt{2}}(\lvert 0 \rangle + \lvert 1 \rangle)$$\pi/2$$\pi/4$$\theta$$\theta$$\theta$$\theta$$\lvert 1 \rangle$$\lvert 1 \rangle$$i$

Qubits and quantum states

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Qubits and quantum states Qubits (quantum bits) are the quantum analog of classical bits: the basic unit of quantum information. Unlike classical bits (0 or 1), a qubit exists in superposition—a linear combination of $\lvert 0 \rangle$ and $\lvert 1 \rangle$ states. A single qubit's state is written as $\lvert \psi \rangle = \alpha \lvert 0 \rangle + \beta \lvert 1 \rangle$$\alpha$$\beta$$|\alpha|^2 + |\beta|^2 = 1$$|\alpha|^2$$|\beta|^2$$n$$2^n$$2^n$$\lvert 0 \rangle$

Simulators

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Simulators Simulators are classical backends that emulate quantum circuits on a classical computer. Qiskit's main simulator is AerSimulator, which tracks the full $2^n$-dimensional state vector and applies unitary operations to it. Simulators are noiseless by default, but you can add

Transpilation

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Transpilation Transpilation converts your abstract quantum circuit into a concrete circuit that runs on a specific backend. Each backend has constraints: a gate set (only certain gates are native), qubit connectivity (which pairs can interact directly), and calibration data. Transpilation rewrites your circuit to respect these constraints while preserving the computation.

Variational algorithms

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Variational algorithms Variational algorithms solve quantum problems by training a quantum circuit (the ansatz) to optimize a classical cost function. The workflow is: (1) design a parameterized circuit, (2) run it with parameters, (3) evaluate a classical cost function, (4) use a classical optimizer to adjust parameters, (5) repeat until convergence.

VQE (variational quantum eigensolver)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
VQE (variational quantum eigensolver) VQE is a variational algorithm that finds ground state energies and eigenstates of quantum Hamiltonians. Given a Hamiltonian $H$ (a Hermitian operator), VQE trains a parameterized circuit to minimize the energy expectation value $E(\theta) = \langle \psi(\theta) | H | \psi(\theta) \rangle$. VQE is one of the most promising near-term quantum algorithms. It's used for chemistry (finding molecular ground states), materials science, and optimization.$E(\theta)…

Qiskit

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Qiskit Qiskit is IBM's open-source Python framework for quantum computing. Build quantum circuits using gates, transpile them for hardware, simulate locally (up to ~20 qubits), and run on IBM quantum processors or other backends. Widely used for variational algorithms (VQE, QAOA), quantum simulation, and education.

QPE

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
QPE 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 Shor's algorithm, the $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\rang…

Quantinuum

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Quantinuum Quantinuum formed in 2021 from the merger of Honeywell Quantum Solutions and Cambridge Quantum. It builds computers on Trapped ion qubits: individual ytterbium and barium ions held in electromagnetic traps, controlled with laser pulses. Its QCCD architecture shuttles ions between separate gate and storage zones on the trap. This lets connectivity be reconfigured in software instead of being fixed at fabrication time.

Quantum algorithm

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
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.

Quantum circuit

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
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{CX}\}$$\varepsilon$$O(\text{polylog}(1/\varepsilon))$$\lvert 0\rangle$$\lvert 1\rangle$

Quantum companies

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:37:02+00:00
Quantum companies Quantum companies develop quantum hardware, software, or services for quantum computing. Companies typically specialize in one qubit modality: superconducting (IBM, Google, Rigetti), trapped ions (IonQ, Honeywell), neutral atoms (Pasqal, Atom Computing), or photonic systems (Xanadu). Others provide software frameworks (CUDA-Q, Qiskit) or classical simulation libraries for algorithm development.

Quantum computing

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Quantum computing Quantum computing is a model of computation that uses quantum-mechanical systems to store and process information. The fundamental unit is the Qubit, the quantum analog of a classical bit. A classical bit is either 0 or 1 at any given moment. A qubit can be in a superposition of both — and multiple qubits can be entangled, meaning their states are correlated in ways that have no classical analog. Those two properties, superposition and entanglement, are the source of quantum c…

Quantum concepts

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Quantum concepts A Qubit lives in a two-dimensional complex Hilbert space $\mathbb{C}^2$. You write its state in Dirac notation as $\lvert\psi\rangle = a\lvert 0\rangle + b\lvert 1\rangle$, where $a$ and $b$ are complex numbers called probability amplitudes, constrained by $|a|^2 + |b|^2 = 1$. The two basis states $\lvert 0\rangle$ and $\lvert 1\rangle$ are the quantum analogs of classical 0 and 1, but before any measurement the qubit genuinely occupies both at once — the amplitudes are not a d…

Quantum error correction

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Quantum error correction Quantum error correction (QEC) is the set of techniques used to protect quantum information from errors caused by decoherence and imperfect gates. Unlike classical bits, which can be copied and checked against redundant copies, quantum states cannot be cloned — any measurement collapses the state. QEC works around this by encoding a single logical qubit into an entangled state of several physical qubits, allowing errors to be detected and corrected without learning anyt…

CCP gate (Controlled-Controlled-Phase)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T17:30:05+00:00
CCP gate (Controlled-Controlled-Phase) CCP applies phase $e^{i\theta}$ to the target if both controls are $|1\rangle$. Parametric doubly-controlled gate for phase estimation and variational algorithms. Action: $|c_1 c_2 t\rangle \to e^{i c_1 c_2 \theta}|c_1 c_2 t\rangle$ where phase is applied only when both controls are $|1\rangle$. $$\text{CCP}(\theta) = \begin{pmatrix} 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 & 0 & 0 &…

CCRx gate (Controlled-Controlled-RX)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T17:30:06+00:00
CCRx gate (Controlled-Controlled-RX) CCRx applies X rotation by $\theta$ to the target if both controls are $|1\rangle$. Parametric doubly-controlled rotation for variational algorithms. Action: $|c_1 c_2 t\rangle \to |c_1 c_2 (R_X(\theta)|t\rangle)\rangle$ where rotation is applied only when both controls are $|1\rangle$. $$\text{CCRx}(\theta) = \begin{pmatrix} 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 \\ …

CCRy gate (Controlled-Controlled-RY)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T17:30:07+00:00
CCRy gate (Controlled-Controlled-RY) CCRy applies Y rotation by $\theta$ to the target if both controls are $|1\rangle$. Parametric doubly-controlled rotation for variational algorithms. Action: $|c_1 c_2 t\rangle \to |c_1 c_2 (R_Y(\theta)|t\rangle)\rangle$ where rotation is applied only when both controls are $|1\rangle$. $$\text{CCRy}(\theta) = \begin{pmatrix} 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 \\ …

CCRz gate (Controlled-Controlled-RZ)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T17:30:08+00:00
CCRz gate (Controlled-Controlled-RZ) CCRz applies Z rotation by $\theta$ to the target if both controls are $|1\rangle$. Parametric doubly-controlled rotation for variational algorithms. Action: $|c_1 c_2 t\rangle \to |c_1 c_2 (R_Z(\theta)|t\rangle)\rangle$ where rotation is applied only when both controls are $|1\rangle$. $$\text{CCRz}(\theta) = \begin{pmatrix} 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 \\ …

CCX gate (Toffoli)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T17:04:20+00:00
CCX gate (Toffoli) CCX (also Toffoli or Controlled-Controlled-X) is a three-qubit gate: flips the target qubit if both control qubits are $|1\rangle$. The quantum AND gate and is universal for reversible classical computation. Action: $|c_1 c_2 t\rangle \to |c_1 c_2 (t \oplus c_1 c_2)\rangle$ where $c_1, c_2$ are controls and $t$$$\text{CCX} = \text{Toffoli} = \begin{pmatrix} 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 & 0 & …

CCY gate (Controlled-Controlled-Y)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T17:30:02+00:00
CCY gate (Controlled-Controlled-Y) CCY (Controlled-Controlled-Y) is a three-qubit gate: applies Y to the target qubit if both control qubits are $|1\rangle$. Like CCX, it is a doubly-controlled gate but less commonly native on quantum platforms. Action: $|c_1 c_2 t\rangle \to |c_1 c_2 (Y|t\rangle)\rangle$ where $c_1, c_2$$t$$$\text{CCY} = \begin{pmatrix} 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0…

CCZ gate (Controlled-Controlled-Z)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T17:30:03+00:00
CCZ gate (Controlled-Controlled-Z) CCZ (Controlled-Controlled-Z or Doubly-Controlled-Z) is a three-qubit gate: applies a phase to the target qubit if both control qubits are $|1\rangle$. Like CZ but doubly-controlled, it is symmetric in all three qubits and less commonly used than CCX on most platforms.$|c_1 c_2 t\rangle \to (-1)^{c_1 c_2 t}|c_1 c_2 t\rangle$$|111\rangle$$-1$$$\text{CCZ} = \begin{pmatrix} 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 & 0 & 0 & …

CiSWAP gate (Controlled-iSWAP)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T17:30:04+00:00
CiSWAP gate (Controlled-iSWAP) CiSWAP applies iSWAP to two qubits if a third control qubit is $|1\rangle$. Swaps and applies phase. Native on some transmon platforms. Action: $|c ab\rangle \to |c (a' b')\rangle$ where iSWAP swaps qubits and applies phase $i$ to $|11\rangle$ when control is $|1\rangle$. $$\text{CiSWAP} = \begin{pmatrix} 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 1 & 0 & 0 &…

Clifford gates

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:46:50+00:00
Clifford gates Clifford gates are unitaries that map Pauli operators to Pauli operators under conjugation: if $C$ is Clifford and $P$ is a Pauli, then $C P C^\dagger$ is also a Pauli (up to global phase). This closure property partitions quantum gates into two classes with profound consequences for simulation, error correction, and the boundary between classical and quantum advantage. Clifford-only circuits are efficiently simulatable classically; adding even one non-Clifford gate requires expo…

Gate composition

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Gate composition Gate composition combines gates into circuits. The order matters: composing gates $U$ then $V$ gives the combined gate $VU$ (right-to-left matrix multiplication). Sequential composition Applying gates in sequence multiplies matrices (right-to-left):$$|\psi_{\text{out}}\rangle = V_n \cdots V_2 V_1 |\psi_{\text{in}}\rangle$$$$U_{\text{total}} = V_n \cdots V_2 V_1$$$$U_1 \otimes U_2 = (U_1 \otimes I)(I \otimes U_2)$$$GG^\dagger = I$$$R_Z(\alpha) R_X(\beta) = U(\alpha, \beta, \ga…

Controlled-Unitary gates

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:53:22+00:00
Controlled-Unitary gates Controlled-unitary (or controlled-$U$) gate applies a unitary operation $U$ to target qubits if and only if all control qubits are $|1\rangle$. It generalizes controlled single-qubit gates (like CNOT) and is fundamental to quantum algorithms including phase estimation, Shor's algorithm, and variational quantum algorithms.$U$$m$$k$$U$$$C^k(U) = |0\rangle\langle 0|_c \otimes I_t + |1\rangle\langle 1|_c \otimes U$$$$C^{c_1 \cdots c_k}(U) = \sum_{x \in \{0,1\}^k} |x\rangle\…

CP gate

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T18:02:09+00:00
CP gate CP gate (controlled-phase) applies a phase to the $|11\rangle$ state, parameterized by angle $\theta$. Matrix: $$\text{CP}(\theta) = \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & e^{i\theta} \end{pmatrix}$$ Special case: $\text{CP}(\pi) = \text{CZ}$. Relation to other gates * Controlled-RZ: $\text{CP}(\theta) = I \otimes I + (I \otimes I - |00\rangle\langle 00| - |01\rangle\langle 01| - |10\rangle\langle 10|) \cdot R_Z(\theta)$ * Parametric CZ: CP…

CSWAP gate (Fredkin)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T17:04:23+00:00
CSWAP gate (Fredkin) CSWAP (also Fredkin or Controlled-SWAP) swaps two qubits if a third control qubit is $|1\rangle$. The quantum analog of a multiplexer and is universal for reversible classical computation. Action: $|c ab\rangle \to |c (a' b')\rangle$ where $a' = c \cdot b + \bar{c} \cdot a$ and $b' = c \cdot a + \bar{c} \cdot b$ (conditional swap). If control is 0, qubits unchanged; if control is 1, qubits swap.$$\text{CSWAP} = \text{Fredkin} = \begin{pmatrix} 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0…

CX gate (Controlled-NOT)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T17:28:45+00:00
CX gate (Controlled-NOT) CX gate (or CNOT gate, Controlled-NOT gate) is the most common two-qubit gate: flips the target qubit if the control qubit is $|1\rangle$. Essential for creating entanglement. Matrix (control on qubit 0, target on qubit 1): $$\text{CX} = \text{CNOT} = \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \end{pmatrix}$$ Action on basis states:$$|00\rangle \to |00\rangle, \quad |01\rangle \to |01\rangle, \quad |10\rangle \to |11\rangle, \qua…

CY gate (Controlled-Y)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T17:30:01+00:00
CY gate (Controlled-Y) CY applies the Y gate to the target qubit if the control qubit is $|1\rangle$. Like CX, it is an asymmetric Clifford two-qubit gate used for entanglement, though less common than CX or CZ on most quantum platforms. Matrix (control on qubit 0, target on qubit 1):$$\text{CY} = \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & -i \\ 0 & 0 & i & 0 \end{pmatrix}$$$$|00\rangle \to |00\rangle, \quad |01\rangle \to |01\rangle, \quad |10\rangle \to i|11\rangle, \quad …

CZ gate (Controlled-Z)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T17:30:02+00:00
CZ gate (Controlled-Z) CZ applies a phase to the $|11\rangle$ state. Symmetric two-qubit gate (control and target are interchangeable). Matrix: $$\text{CZ} = \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & -1 \end{pmatrix}$$ Action: $|ab\rangle \to (-1)^{ab}|ab\rangle$ (applies $-1$ phase to $|11\rangle$). Relation to CNOT CZ and CNOT are related via Hadamards on the target: $$\text{CZ}_{01} = (I \otimes H) \text{CX}_{01} (I \otimes H)$$ $$\text{CNOT} = (I …

Gate decomposition

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Gate decomposition Gate decomposition breaks complex gates into simpler, more fundamental gates. Useful for implementing gates not native on specific hardware or for circuit optimization. Single-Qubit decomposition Any single-qubit unitary can be decomposed as:$$U = e^{i\alpha} R_Z(\beta) R_X(\gamma) R_Z(\delta)$$$$U = e^{i\alpha} R_X(\beta) R_Z(\gamma) R_X(\delta)$$$$U_{2Q} = (A \otimes B) \text{CNOT} (C \otimes D) \text{CNOT} (E \otimes F)$$

Gate fidelity and errors

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Gate fidelity and errors Gate fidelity measures how accurately a physical gate implements the ideal unitary. Imperfect gates accumulate errors, reducing quantum advantage. Fidelity definition Average gate fidelity: $F = \frac{1}{d+1} \text{Tr}(\rho_{\text{ideal}} \rho_{\text{actual}})$ where $d$ is dimension (2 for qubits).$F_p = \text{Tr}(U_{\text{ideal}}^\dagger U_{\text{actual}}) / d$$F > 0.999$$n$$F$$\approx F^n$$0.999^{1000} \approx 37\%$

Grover diffusion operator

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:46:58+00:00
Grover diffusion operator Grover diffusion operator (inversion about average) is an $n$-qubit gate that amplifies marked states in a superposition by reflecting all amplitudes about their average value. It is the core component of Grover's quantum search algorithm and amplitude amplification, enabling quadratic speedup in unstructured search.$n$$$D = 2|\psi_0\rangle\langle\psi_0| - I$$$|\psi_0\rangle = \frac{1}{\sqrt{2^n}} \sum_{j=0}^{2^n-1} |j\rangle$$$D = H^{\otimes n} (2|0\rangle\langle 0| -…

Hadamard gate

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Hadamard gate Hadamard (H) creates equal superposition from basis states and is fundamental to quantum algorithms. Matrix: $$H = \frac{1}{\sqrt{2}} \begin{pmatrix} 1 & 1 \\ 1 & -1 \end{pmatrix}$$ Action: $$H|0\rangle = \frac{|0\rangle + |1\rangle}{\sqrt{2}}$$ $$H|1\rangle = \frac{|0\rangle - |1\rangle}{\sqrt{2}}$$ Properties * Self-inverse: $H^2 = I$ * Hermitian: $H = H^\dagger$ * Eigenvalues: $+1, -1$ with eigenvectors $(|0\rangle + |1\rangle)/\sqrt{2}$ and $(|0\rangle - |1\rangle)/…

Identity gate (I)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Identity gate (I) Identity (I or $I$) is the trivial single-qubit gate that leaves the quantum state unchanged. The quantum analog of the “do nothing” operation. Every quantum state is an eigenvector of the identity gate with eigenvalue 1. Matrix:$$I = \begin{pmatrix} 1 & 0 \\ 0 & 1 \end{pmatrix}$$$$I|\psi\rangle = |\psi\rangle$$$$I|0\rangle = |0\rangle, \quad I|1\rangle = |1\rangle$$$I^2 = I$$I^\dagger = I$$[I, U] = 0$$U$$U U^\dagger = I$

iSWAP gate

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
iSWAP gate iSWAP swaps two qubits and applies a phase factor. Often a native gate on superconducting qubit systems. Matrix: $$\text{iSWAP} = \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 0 & i & 0 \\ 0 & i & 0 & 0 \\ 0 & 0 & 0 & 1 \end{pmatrix}$$ Action: $|ab\rangle \to i^{\delta_{ab}} |ba\rangle$ where $\delta_{ab} = 1$ if $a \neq b$, else 0. Specifically: swaps $|01\rangle \to i|10\rangle$ and $|10\rangle \to i|01\rangle$, while leaving $|00\rangle$ and $|11\rangle$ unchanged. Relation to SWAP $…

Gate matrices and notation

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Gate matrices and notation Gate matrices represent quantum gates as unitary matrices. Understanding notation and matrix properties is essential for gate design and analysis. Matrix representation A gate on $n$ qubits is a $2^n \times 2^n$ unitary matrix $U$ satisfying:$$U^\dagger U = U U^\dagger = I$$$U^\dagger$$\langle \psi | U^\dagger U | \psi \rangle = \langle \psi | \psi \rangle = 1$$n$$|0\rangle, |1\rangle, \ldots, |2^n - 1\rangle$$$|0\rangle = \begin{pmatrix} 1 \\ 0 \end{pmatrix}, \quad…

Multi-qubit gates (n-qubit general)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Multi-qubit gates (n-qubit general) Multi-qubit gates act on arbitrary numbers of qubits ($n \geq 3$) and are fundamental to quantum algorithms. Unlike three-qubit gates like Toffoli and Fredkin, general multi-qubit gates have no fixed size and scale with problem parameters. Most are constructed from two-qubit gates and are expensive to implement natively.$|i\rangle \to |i \oplus 1 \pmod{n}\rangle$$n$$|j\rangle \to \frac{1}{\sqrt{2^n}} \sum_{k=0}^{2^n-1} e^{2\pi i jk/2^n} |k\rangle$$O(n^2)$$n$$…

Non-Clifford gates

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:17:23+00:00
Non-Clifford gates Non-Clifford gates are unitary operations that do NOT map Pauli operators to Pauli operators under conjugation. If $N$ is non-Clifford and $P$ is a Pauli, then $N P N^\dagger$ is generally not Pauli. This breakdown of closure with respect to the Pauli group is precisely what enables universal quantum computation. Non-Clifford gates are the computational bottleneck in fault-tolerant quantum computing: while $\pi/4$$T = R_Z(\pi/4)$$T^8 = I$$-\pi/4$$T^\dagger = R_Z(-\pi/4)$$R_X(…

P gate (Phase gate)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T17:57:42+00:00
P gate (Phase gate) P gate applies a phase $e^{i\theta}$ to the $|1\rangle$ state, leaving $|0\rangle$ unchanged. It is a parameterized single-qubit gate that rotates around the z-axis on the Bloch sphere. With specific angle choices, the P gate becomes S ($\theta = \pi/2$), T ($\theta = \pi/4$), or Z ($\theta = \pi$). Matrix: $$P(\theta) = \begin{pmatrix} 1 & 0 \\ 0 & e^{i\theta} \end{pmatrix}$$$P(\theta)|0\rangle = |0\rangle$$P(\theta)|1\rangle = e^{i\theta}|1\rangle$$\theta$$|1\rangle$$\the…

Parametric gates

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Parametric gates Parametric gates depend on a continuous parameter $\theta$, enabling tunable operations. Essential for variational algorithms and pulse control. Single-Qubit rotations $$R_X(\theta) = e^{-i\theta X/2} = \begin{pmatrix} \cos(\theta/2) & -i\sin(\theta/2) \\ -i\sin(\theta/2) & \cos(\theta/2) \end{pmatrix}$$ $$R_Y(\theta) = e^{-i\theta Y/2} = \begin{pmatrix} \cos(\theta/2) & -\sin(\theta/2) \\ \sin(\theta/2) & \cos(\theta/2) \end{pmatrix}$$ $$R_Z(\theta) = e^{-i\theta Z/2} = \b…

Pauli gates

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:58:50+00:00
Pauli gates Pauli gates (I, X, Y, Z) form the fundamental set of single-qubit gates that generate the Pauli group. They are Clifford gates with eigenvalues ±1 and well-defined commutation relations, making them essential for quantum error correction, measurement, and circuit decomposition. Any single-qubit unitary can be expressed as a linear combination of Paulis.$|0\rangle \leftrightarrow |1\rangle$$Y = iXZ$$-1$$|1\rangle$$$I = \begin{pmatrix} 1 & 0 \\ 0 & 1 \end{pmatrix} \quad X = \begin{pma…

Permutation gate

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Permutation gate Permutation gate applies a classical permutation to the computational basis states of $n$ qubits. It is a unitary operation that reorders basis states according to a permutation $\pi$: $|j\rangle \to |\pi(j)\rangle$. Permutation gates are reversible, preserve the Hamming weight (number of 1s), and can be efficiently decomposed into two-qubit gates.$n$$\pi: \{0,1,\ldots,2^n-1\} \to \{0,1,\ldots,2^n-1\}$$$P_\pi |j\rangle = |\pi(j)\rangle$$$P_\pi[i][j] = 1$$j = \pi^{-1}(i)$$|j\ran…

Phase oracle gate

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Phase oracle gate Phase oracle (or problem oracle) is an $n$-qubit gate that marks solutions to a computational problem by applying a phase (typically $-1$) to basis states satisfying a Boolean predicate $f: \{0,1\}^n \to \{0,1\}$. Phase oracles are fundamental to quantum search and optimization algorithms, encoding the problem structure into quantum interference.$f(x)$$x \in \{0,1\}^n$$$O_f = \sum_{x=0}^{2^n-1} (-1)^{f(x)} |x\rangle\langle x|$$$$O_f |x\rangle = (-1)^{f(x)} |x\rangle$$$f(x) = 0…

Phase gates

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T17:57:51+00:00
Phase gates Phase gates are single-qubit gates that apply phase shifts to the computational basis states without changing their amplitudes. They are rotations around the z-axis on the Bloch sphere ($R_Z(\theta)$ gates with specific angles). Phase gates are diagonal in the computational basis and leave $|0\rangle$$|1\rangle$$\theta$$\theta$$P(\theta) = R_Z(\theta)$$\pi/2$$S = R_Z(\pi/2)$$S^4 = I$$-\pi/2$$S^\dagger = R_Z(-\pi/2)$$\pi/4$$T = R_Z(\pi/4)$$T^8 = I$$-\pi/4$$T^\dagger = R_Z(-\pi/4)$$\p…

Physical implementation

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Physical implementation Physical implementation of quantum gates depends on the quantum computing platform. Different platforms (superconducting, trapped ion, photonic, etc.) realize gates differently. Superconducting qubits Gates via microwave pulses

Quantum Fourier transform (QFT)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Quantum Fourier transform (QFT) Quantum Fourier Transform is an $n$-qubit unitary gate that maps the computational basis state $|j\rangle$ to a uniform superposition with phases determined by $j$. It is the quantum analogue of the classical discrete Fourier transform and is a subroutine in Shor's factoring algorithm, phase estimation, and other quantum algorithms.$n$$$\text{QFT}|j\rangle = \frac{1}{\sqrt{2^n}} \sum_{k=0}^{2^n-1} e^{2\pi i jk/2^n} |k\rangle$$$\text{QFT}[k][j] = \frac{1}{\sqrt{2^…

Rotation gates

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:51:19+00:00
Rotation gates Rotation gates ($R_X$, $R_Y$, $R_Z$) are parametric single-qubit gates that apply rotations around the x, y, z axes of the Bloch sphere by angle $\theta$. They are fundamental building blocks for state preparation and variational quantum algorithms, since any single-qubit unitary can be decomposed as a product of rotations around two perpendicular axes.$R_X(\theta)$$\theta$$R_Y(\theta)$$\theta$$R_Z(\theta)$$\theta$$$R_X(\theta) = \begin{pmatrix} \cos(\theta/2) & -i\sin(\theta/2) …

Rx gate (rotation around X)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:15:28+00:00
Rx gate (rotation around X) Rx rotates a qubit around the x-axis by angle $\theta$. Matrix: $$R_X(\theta) = \begin{pmatrix} \cos(\theta/2) & -i\sin(\theta/2) \\ -i\sin(\theta/2) & \cos(\theta/2) \end{pmatrix}$$ Action: $R_X(\theta)|\psi\rangle$ rotates $|\psi\rangle$ by $\theta$ radians around x-axis on Bloch sphere. Special cases: * $R_X(0) = I$ (identity) * $R_X(\pi/2) = \frac{1}{\sqrt{2}}\begin{pmatrix} 1 & -i \\ -i & 1 \end{pmatrix}$ * $R_X(\pi) = -i X$ (equivalent to Pauli X up to …

Ry gate (rotation around Y)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:15:35+00:00
Ry gate (rotation around Y) Ry rotates a qubit around the y-axis by angle $\theta$. Matrix: $$R_Y(\theta) = \begin{pmatrix} \cos(\theta/2) & -\sin(\theta/2) \\ \sin(\theta/2) & \cos(\theta/2) \end{pmatrix}$$ Action: $R_Y(\theta)|\psi\rangle$ rotates $|\psi\rangle$ by $\theta$ radians around y-axis on Bloch sphere. Special cases: * $R_Y(0) = I$ * $R_Y(\pi/2) = \frac{1}{\sqrt{2}}\begin{pmatrix} 1 & -1 \\ 1 & 1 \end{pmatrix}$ * $R_Y(\pi) = -i Y$ (equivalent to Pauli Y up to global phase) …

Rz gate (rotation around Z)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:15:41+00:00
Rz gate (rotation around Z) Rz rotates a qubit around the z-axis by angle $\theta$. Matrix: $$R_Z(\theta) = \begin{pmatrix} e^{-i\theta/2} & 0 \\ 0 & e^{i\theta/2} \end{pmatrix}$$ Action: $R_Z(\theta)|\psi\rangle$ rotates $|\psi\rangle$ by $\theta$ radians around z-axis on Bloch sphere, or equivalently, applies phase factors. Special cases: * $R_Z(0) = I$ * $R_Z(\pi/2) = \frac{1}{\sqrt{2}}\begin{pmatrix} e^{-i\pi/4} & 0 \\ 0 & e^{i\pi/4} \end{pmatrix}$ (related to S gate) * $R_Z(\pi) = …

S† gate (inverse S gate)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T17:58:08+00:00
S† gate (inverse S gate) S† gate (also written S-dagger or S inverse) applies a $-90°$ phase to the $|1\rangle$ state. It is the inverse of the S gate, with $S^\dagger S = I$ and $S^\dagger = S^3$ (since $S^4 = I$). Matrix: $$S^\dagger = \begin{pmatrix} 1 & 0 \\ 0 & -i \end{pmatrix}$$ Action: $S^\dagger|0\rangle = |0\rangle$, $S^\dagger|1\rangle = -i|1\rangle$ (adds $-\pi/2$ phase to $|1\rangle$). Properties * Inverse of S: $S^\dagger S = S S^\dagger = I$ * Self-adjoint modulo phase$(S^\…

S gate

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T17:58:07+00:00
S gate S gate applies a 90° phase to the $|1\rangle$ state, also called the phase gate or $\sqrt{Z}$ (since $S^2 = Z$). Matrix: $$S = \begin{pmatrix} 1 & 0 \\ 0 & i \end{pmatrix}$$ Action: $S|0\rangle = |0\rangle$, $S|1\rangle = i|1\rangle$ (adds $\pi/2$ phase to $|1\rangle$). Properties * : applying S twice gives the Z gate * : applying S four times returns to identity * Inverse: $S^\dagger = -iZ S = \begin{pmatrix} 1 & 0 \\ 0 & -i \end{pmatrix}$ * Part of Clifford group$$S = R_Z(\pi/…

Single-qubit gates

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T18:16:40+00:00
Single-qubit gates Single-qubit gates are unitary operations that act on one qubit. They are represented by $2 \times 2$ unitary matrices and form the Lie group $\mathrm{SU}(2)$. Every quantum computation can be decomposed into single-qubit rotations and two-qubit entangling gates (e.g., CNOT), making single-qubit gates the fundamental building blocks of quantum circuits.$|\psi\rangle$$U|\psi\rangle$$S^4 = I$$T^8 = I$$\theta$$\mathrm{SU}(2)$$R_X$$R_Y$$R_Z$$U(\phi, \theta, \lambda)$$2 \times 2$$…

Stabilizer formalism

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:59:09+00:00
Stabilizer formalism Stabilizer formalism is a mathematical framework for representing and efficiently simulating certain quantum states (stabilizer states) using only Pauli operations. A stabilizer state is uniquely defined as the eigenstate with eigenvalue $+1$ of a set of commuting Pauli operators (stabilizers). This restriction enables polynomial-time simulation of Clifford circuits and provides the foundation for quantum error correction.$|\psi\rangle$$$S_i |\psi\rangle = |\psi\rangle$$$S_…

SWAP gate

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
SWAP gate SWAP exchanges the states of two qubits. If qubit 1 is in state $|a\rangle$ and qubit 2 is in state $|b\rangle$, after SWAP they exchange. Matrix: $$\text{SWAP} = \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 \end{pmatrix}$$ Action: $|ab\rangle \to |ba\rangle$ (swap basis state labels). Properties * Self-inverse: $\text{SWAP}^2 = I$ * Symmetric: swaps two qubits * Reduces to identity$$\text{SWAP} = \text{CX}_{01} \text{CX}_{10} \text{CX}_{01}…

T† gate (inverse T gate)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:10:25+00:00
T† gate (inverse T gate) T† gate (also written T-dagger or T inverse) applies a $-45°$ phase to the $|1\rangle$ state. It is the inverse of the T gate, with $T^\dagger T = I$ and $T^\dagger = T^7$ (since $T^8 = I$). Like the T gate, T† is non-Clifford and essential for universal quantum computation. Matrix:$$T^\dagger = \begin{pmatrix} 1 & 0 \\ 0 & e^{-i\pi/4} \end{pmatrix}$$$T^\dagger|0\rangle = |0\rangle$$T^\dagger|1\rangle = e^{-i\pi/4}|1\rangle$$-\pi/4$$|1\rangle$$T^\dagger T = T T^\dagger…

T gate

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:11:02+00:00
T gate T gate applies a 45° phase to the $|1\rangle$ state. Crucial for universal quantum computation and magic state distillation. Matrix: $$T = \begin{pmatrix} 1 & 0 \\ 0 & e^{i\pi/4} \end{pmatrix}$$ Action: $T|0\rangle = |0\rangle$, $T|1\rangle = e^{i\pi/4}|1\rangle$ (adds $\pi/4$ phase to $|1\rangle$). Properties * : applying T eight times returns to identity * : four T gates equal one Z gate$T^\dagger = e^{-i\pi/4}$$T^7$$$T = R_Z(\pi/4) = e^{-i\pi Z/8}$$$$S = T^2 = R_Z(\pi/2)$$$$Z =…

Three-qubit gates

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T17:49:31+00:00
Three-qubit gates Three-qubit gates are unitary operations that act on a triple of qubits. They are represented by $8 \times 8$ unitary matrices and form the Lie group $\mathrm{SU}(8)$. Beyond what two-qubit gates offer, three-qubit gates expose genuinely tripartite entanglement, correlation that can't be reduced to any pair of qubits, and several of them (CCX, CSWAP) are universal for classical reversible computation on their own.$|\psi\rangle \in \mathbb{C}^8$$U|\psi\rangle$$\mathrm{SU}(8)$$\…

Two-qubit gates

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T18:03:32+00:00
Two-qubit gates Two-qubit gates are unitary operations that act on a pair of qubits. They are represented by $4 \times 4$ unitary matrices and form the Lie group $\mathrm{SU}(4)$. Unlike single-qubit gates, which only rotate individual qubits on their own Bloch spheres, two-qubit gates can create entanglement between qubits, which is what makes a quantum computer more than a collection of independent classical bits.$|\psi\rangle \in \mathbb{C}^4$$U|\psi\rangle$$n$$A \otimes B$$A, B$$\text{XX}$$…

U (Universal single-qubit gate)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:14:49+00:00
U (Universal single-qubit gate) U gate is the most general single-qubit unitary with three parameters. Can represent any single-qubit gate. Matrix: $$U(\theta, \phi, \lambda) = \begin{pmatrix} \cos(\theta/2) & -e^{i\lambda}\sin(\theta/2) \\ e^{i\phi}\sin(\theta/2) & e^{i(\phi+\lambda)}\cos(\theta/2) \end{pmatrix}$$ Parameters: * $\theta \in [0, \pi]$: rotation angle (related to Y-axis rotation) * $\phi \in [0, 2\pi]$: first phase parameter * $\lambda \in [0, 2\pi]$: second phase paramete…

Universal gate sets

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Universal gate sets Universal gate sets are minimal collections of gates that can approximate any unitary operation to arbitrary precision. Different sets are universal; the choice depends on hardware availability. Single-Qubit + CNOT The most common set: arbitrary single-qubit gates (e.g., RX, RY, RZ) plus CNOT. This set is $n$$\epsilon$$O(\log^{3+\delta}(1/\epsilon))$$\pi/8$$\theta$$\theta$

Pauli X gate (not)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Pauli X gate (not) Pauli X (also NOT) is the simplest quantum gate: it flips a qubit from $|0\rangle$ to $|1\rangle$ and vice versa. Matrix: $$X = \begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix}$$ Action: $X|0\rangle = |1\rangle$, $X|1\rangle = |0\rangle$. Properties * Self-inverse: $X^2 = I$ (applying twice gives identity) * Eigenvalues: $+1, -1$ with eigenvectors $(|0\rangle + |1\rangle)/\sqrt{2}$ and $(|0\rangle - |1\rangle)/\sqrt{2}$ * Commutes with$|1\rangle$$|0\rangle$$\pi$$\pi$$\pi$…

XX gate (Ising coupling)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T17:36:23+00:00
XX gate (Ising coupling) XX gate is a parametric two-qubit gate implementing the interaction Hamiltonian $H = \theta X_1 X_2$. Natural in some quantum systems. Matrix: $$\text{XX}(\theta) = \exp(-i\theta X_1 X_2 / 2) = \begin{pmatrix} \cos(\theta/2) & 0 & 0 & -i\sin(\theta/2) \\ 0 & \cos(\theta/2) & -i\sin(\theta/2) & 0 \\ 0 & -i\sin(\theta/2) & \cos(\theta/2) & 0 \\ -i\sin(\theta/2) & 0 & 0 & \cos(\theta/2) \end{pmatrix}$$ Action: applies correlated X rotations to both qubits simultaneously…

Pauli Y gate

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Pauli Y gate Pauli Y combines a bit flip (X) and a phase flip (Z), with a relative phase. Matrix: $$Y = \begin{pmatrix} 0 & -i \\ i & 0 \end{pmatrix}$$ Action: $Y|0\rangle = i|1\rangle$, $Y|1\rangle = -i|0\rangle$. Properties * Self-inverse: $Y^2 = I$ * Eigenvalues: $+1, -1$ with eigenvectors $(|0\rangle + i|1\rangle)/\sqrt{2}$ and $(|0\rangle - i|1\rangle)/\sqrt{2}$ * Commutation: anticommutes with X and Z * Relation to X and Z$Y = iXZ = iZX$$\pi$$\pi$$Y = RX(\pi/2) Z RX(-\pi/2)$

YY gate (Ising coupling)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T17:36:29+00:00
YY gate (Ising coupling) YY gate is a parametric two-qubit gate implementing correlated Y rotations on both qubits. Matrix: $$\text{YY}(\theta) = \exp(-i\theta Y_1 Y_2 / 2) = \begin{pmatrix} \cos(\theta/2) & 0 & 0 & i\sin(\theta/2) \\ 0 & \cos(\theta/2) & -i\sin(\theta/2) & 0 \\ 0 & -i\sin(\theta/2) & \cos(\theta/2) & 0 \\ i\sin(\theta/2) & 0 & 0 & \cos(\theta/2) \end{pmatrix}$$ Action: entangling two-qubit rotation around YY axis. Special cases * $\text{YY}(0) = I$ * $\text{YY}(\pi/2)$ …

Pauli Z gate

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Pauli Z gate Pauli Z applies a phase flip: $|0\rangle$ unchanged, $|1\rangle$ gets a $-1$ phase. Matrix: $$Z = \begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix}$$ Action: $Z|0\rangle = |0\rangle$, $Z|1\rangle = -|1\rangle$. Properties * Self-inverse: $Z^2 = I$ * Eigenvalues: $+1, -1$ with eigenvectors $|0\rangle$ and $|1\rangle$ (computational basis) * Diagonal: doesn't mix basis states, only applies phases * $\pi$$U(\theta, \phi, \lambda) = R_Z(\phi) R_Y(\theta) R_Z(\lambda)$$\pi$

ZZ gate (Ising coupling)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T17:36:31+00:00
ZZ gate (Ising coupling) ZZ gate is a parametric two-qubit gate implementing correlated Z rotations. Among the most commonly available parametric gates. Matrix: $$\text{ZZ}(\theta) = \exp(-i\theta Z_1 Z_2 / 2) = \begin{pmatrix} e^{-i\theta/2} & 0 & 0 & 0 \\ 0 & e^{i\theta/2} & 0 & 0 \\ 0 & 0 & e^{i\theta/2} & 0 \\ 0 & 0 & 0 & e^{-i\theta/2} \end{pmatrix}$$ Action: applies correlated phase rotations; leaves computational basis unchanged, only phases states.$\text{ZZ}(0) = I$$\text{ZZ}(\pi/2)$…

Quantum gate

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T18:02:48+00:00
Quantum gate Quantum gates are unitary operations that transform quantum states. Like classical logic gates (AND, OR, NOT), quantum gates manipulate qubits -- but they preserve superposition and enable entanglement. Every quantum gate is reversible (unitary matrix $U$$U^\dagger U = I$$n$$2^n \times 2^n$$\mathrm{SU}(2^n)$$|\psi\rangle$$U|\psi\rangle$

Quantum hardware

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:37:11+00:00
Quantum hardware Quantum hardware is the physical substrate for quantum computation. Main modalities: superconducting qubits (IBM, Google, Rigetti; ~1 μs coherence), trapped ions (IonQ, Honeywell; ~100 ms coherence, high fidelity), neutral atoms (Pasqal, Atom Computing; scalable but addressing challenges), photonic qubits (Xanadu; room temperature), and topological qubits (research stage). Near-term systems span 10–1000 qubits with error rates 0.1–1%; scaling and reducing errors below 10^-4 are…

Quantum register

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Quantum register Quantum register is a register made out of qubits. It is the quantum equivalent of a classical CPU register. Classical CPU regsiters are made out of bits and are used to store number values. For example, a classical 16-bit register, like Intel 8086's $c = \frac{1}{\sqrt 2}(1 + i)$$|c_{63}|^2 = 0.75$$63$$\lvert\text{Qreg}\rangle$$\lvert\cdot\rangle$$$\begin{aligned} \lvert\text{Qreg}\rangle = \sum_{k = 0}^{k = 2^{16} - 1} c_k\lvert k\rangle = (x_0 + i y_0)\lvert\text{0}\rangle …

Quantum software

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:37:07+00:00
Quantum software Quantum software includes programming frameworks, simulators, and transpilers for quantum algorithms. Libraries provide circuit builders (Qiskit, CUDA-Q), simulators for ~20 qubits (cuStateVec, QuTiP), and compilation to hardware-native gate sets. Research tools (scqubits, QuTiP) focus on open quantum systems; production frameworks emphasize variational algorithms (VQE, QAOA) with classical optimization loops. Most frameworks are Python-based with GPU acceleration available (CU…

Zero state (|0⟩)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Zero state (|0⟩) Zero state (or ground state) $|0\rangle$ is the computational basis state corresponding to a classical bit value 0. It is the standard initial state of qubits in most quantum computers and one of the two eigenstates of the Pauli Z operator. $|0\rangle = \begin{pmatrix} 1 \\ 0 \end{pmatrix}$$Z|0\rangle = |0\rangle$$|1\rangle$$\langle 0|1\rangle = 0$$\langle 0|0\rangle = 1$$\rho = |0\rangle\langle 0| = \begin{pmatrix} 1 & 0 \\ 0 & 0 \end{pmatrix}$$|0\rangle$$|0\rangle$$R_X(\pi)$$…

One state (|1⟩)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
One state (|1⟩) One state (or excited state) $|1\rangle$ is the computational basis state corresponding to a classical bit value 1. It is the second basis state and one of the two eigenstates of the Pauli Z operator. Representation: $|1\rangle = \begin{pmatrix} 0 \\ 1 \end{pmatrix}$ Properties * Eigenstate of Z with eigenvalue -1: $Z|1\rangle = -|1\rangle$$|0\rangle$$\langle 1|0\rangle = 0$$\langle 1|1\rangle = 1$$\rho = |1\rangle\langle 1| = \begin{pmatrix} 0 & 0 \\ 0 & 1 \end{pmatrix}$$|0…

Basis states and measurement

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Basis states and measurement Basis states form an orthonormal set that spans the Hilbert space of a quantum system. A qubit has two computational basis states $|0\rangle$ and $|1\rangle$; any qubit state can be written as a superposition of these. Measurement projects a state onto one basis state, collapsing superposition to a definite outcome.$\{|0\rangle, |1\rangle\}$$\{|+\rangle, |-\rangle\}$$\{|+i\rangle, |-i\rangle\}$$|\psi\rangle = \alpha|0\rangle + \beta|1\rangle$$|\alpha|^2$$|\beta|^2$$…

Bell 00 (|Φ⁺⟩)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:47:06+00:00
Bell 00 (|Φ⁺⟩) Bell 00 state $|\Phi^+\rangle = \frac{1}{\sqrt{2}}(|00\rangle + |11\rangle)$ is the maximally entangled two-qubit state where both qubits have perfectly correlated measurement outcomes. It cannot be written as a product of single-qubit states and is one of the four Bell states. Representation: $|\Phi^+\rangle = \frac{1}{\sqrt{2}} \begin{pmatrix} 1 \\ 0 \\ 0 \\ 1 \end{pmatrix}$ (in the basis $|00\rangle, |01\rangle, |10\rangle, |11\rangle$$|00\rangle$$|11\rangle$$1/\sqrt{2}$$|\Ph…

Bell 01 (|Ψ⁺⟩)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:47:01+00:00
Bell 01 (|Ψ⁺⟩) Bell 01 state $|\Psi^+\rangle = \frac{1}{\sqrt{2}}(|01\rangle + |10\rangle)$ is a maximally entangled two-qubit state where the measurement outcomes of the two qubits are anti-correlated. One of the four Bell states, it is equally likely to yield outcomes 01 or 10 when measured. Representation: $|\Psi^+\rangle = \frac{1}{\sqrt{2}} \begin{pmatrix} 0 \\ 1 \\ 1 \\ 0 \end{pmatrix}$ (in the basis $|00\rangle, |01\rangle, |10\rangle, |11\rangle$$Z_1 Z_2$$(Z \otimes Z)|\Psi^+\rangle = …

Bell 10 (|Ψ⁻⟩)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Bell 10 (|Ψ⁻⟩) Bell 10 state $|\Psi^-\rangle = \frac{1}{\sqrt{2}}(|01\rangle - |10\rangle)$ is a maximally entangled two-qubit state with anti-correlated measurements and a relative minus phase. One of the four Bell states. Representation: $|\Psi^-\rangle = \frac{1}{\sqrt{2}} \begin{pmatrix} 0 \\ 1 \\ -1 \\ 0 \end{pmatrix}$ (in the basis $|00\rangle, |01\rangle, |10\rangle, |11\rangle$) Properties * Maximally entangled: cannot be factored into independent qubit states$Z_1 Z_2$$(Z \otimes Z)…

Bell 11 (|Φ⁻⟩)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
Bell 11 (|Φ⁻⟩) Bell 11 state $|\Phi^-\rangle = \frac{1}{\sqrt{2}}(|00\rangle - |11\rangle)$ is a maximally entangled two-qubit state with perfectly correlated measurements and a relative minus phase. One of the four Bell states. Representation: $|\Phi^-\rangle = \frac{1}{\sqrt{2}} \begin{pmatrix} 1 \\ 0 \\ 0 \\ -1 \end{pmatrix}$ (in the basis $|00\rangle, |01\rangle, |10\rangle, |11\rangle$) Properties * Maximally entangled: cannot be factored into independent qubit states$Z_1 Z_2$$(Z \otim…

Bell states

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Bell states Bell states are the four maximally entangled two-qubit states. They form a complete orthonormal basis for two-qubit Hilbert space and are fundamental to quantum communication, quantum cryptography, and quantum teleportation. The four Bell states $|\Phi^+\rangle = \frac{1}{\sqrt{2}}(|00\rangle + |11\rangle)$$Z_1 Z_2$$|\Phi^-\rangle = \frac{1}{\sqrt{2}}(|00\rangle - |11\rangle)$$Z_1 Z_2$$|\Psi^+\rangle = \frac{1}{\sqrt{2}}(|01\rangle + |10\rangle)$$Z_1 Z_2$$|\Psi^-\rangle = \frac{1}{…

Bloch sphere representation

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Bloch sphere representation Bloch sphere is a geometric representation of single-qubit states as points on a 3D sphere of radius 1. Any pure single-qubit state $|\psi\rangle = \cos(\theta/2)|0\rangle + e^{i\phi}\sin(\theta/2)|1\rangle$ maps to a unique point on the Bloch sphere with spherical coordinates $(\theta, \phi)$, where $\theta \in [0, \pi]$ and $\phi \in [0, 2\pi)$. Coordinate mapping $\theta = 0$$|0\rangle$$\theta = \pi$$|1\rangle$$\theta = \pi/2, \phi = 0$$|+\rangle$$\theta = \pi/2,…

Choi state

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Choi state Choi state is a canonical maximally entangled bipartite state used to represent a quantum channel. The Choi-Jamiolkowski correspondence maps quantum channels to density matrices, enabling process tomography, channel capacity analysis, and characterization of quantum operations via entangled state measurements.$\mathcal{E}: \mathcal{H}_A \to \mathcal{H}_B$$d_A$$d_B$$$\rho_{\text{Choi}} = (\mathcal{I}_A \otimes \mathcal{E}_B)(|\Phi_d\rangle\langle\Phi_d|)$$$|\Phi_d\rangle = \frac{1}{\s…

Cluster state

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Cluster state Cluster state is a multi-qubit entangled state arranged in a one-dimensional, two-dimensional, or higher-dimensional lattice where neighboring qubits are entangled via CZ interactions. Cluster states are the resource for measurement-based quantum computing (one-way quantum computing).$n$$|+\rangle$$\text{CZ}_{i,i+1}$$Z_i Z_{i+1}$

Computational 00 (|00⟩)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Computational 00 (|00⟩) Computational 00 state |00⟩ is the product of two ground state qubits, the default initial state on most quantum computers. It is a separable (unentangled) state and an eigenstate of both Z₁ and Z₂ operators with eigenvalue +1.$$|00\rangle = |0\rangle_1 \otimes |0\rangle_2 = \begin{pmatrix} 1 \\ 0 \\ 0 \\ 0 \end{pmatrix}$$

Computational 01 (|01⟩)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Computational 01 (|01⟩) Computational 01 state |01⟩ is a product state with the first qubit in ground state and the second qubit in excited state. It is separable (unentangled) and an eigenstate of both Z₁ and Z₂ operators with eigenvalues +1 and -1 respectively.$$|01\rangle = |0\rangle_1 \otimes |1\rangle_2 = \begin{pmatrix} 0 \\ 1 \\ 0 \\ 0 \end{pmatrix}$$

Computational 10 (|10⟩)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Computational 10 (|10⟩) Computational 10 state |10⟩ is a product state with the first qubit in excited state and the second qubit in ground state. It is separable (unentangled) and an eigenstate of both Z₁ and Z₂ operators with eigenvalues -1 and +1 respectively.$$|10\rangle = |1\rangle_1 \otimes |0\rangle_2 = \begin{pmatrix} 0 \\ 0 \\ 1 \\ 0 \end{pmatrix}$$

Computational 11 (|11⟩)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Computational 11 (|11⟩) Computational 11 state |11⟩ is the product of two excited state qubits. It is a separable (unentangled) state and an eigenstate of both Z₁ and Z₂ operators with eigenvalue -1. Definition $$|11\rangle = |1\rangle_1 \otimes |1\rangle_2 = \begin{pmatrix} 0 \\ 0 \\ 0 \\ 1 \end{pmatrix}$$ in the computational basis ordering (|00⟩, |01⟩, |10⟩, |11⟩).

Two-qubit computational basis states

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
Two-qubit computational basis states Two-qubit computational basis states are the four orthonormal product states |00⟩, |01⟩, |10⟩, |11⟩ that form the default measurement basis on quantum computers. They represent definite, unentangled configurations of two qubits and are eigenstates of the Z operator on both qubits.$|00\rangle$$|01\rangle$$|10\rangle$$|11\rangle$$\langle ij | kl \rangle = \delta_{ik}\delta_{jl}$$i,j,k,l \in \{0,1\}$$|00\rangle = |0\rangle \otimes |0\rangle$$|01\rangle = |0\ran…

Computational basis states

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Computational basis states Computational basis states $|0\rangle$ and $|1\rangle$ are the two orthogonal eigenstates of the Pauli Z operator. They represent the classical outcomes 0 and 1 and form the default measurement basis on most quantum computers. Overview * Zero state (|0⟩): eigenstate with $Z|0\rangle = |0\rangle$$Z|1\rangle = -|1\rangle$$\langle 0|1\rangle = 0$$\langle 0|0\rangle = \langle 1|1\rangle = 1$$\rho = |i\rangle\langle i|$$i \in \{0, 1\}$$|0\rangle$$|0\rangle$$|1\rangle$$n…

Density matrices and mixed states

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Density matrices and mixed states Density matrix $\rho$ is a mathematical representation of a quantum state that generalizes state vectors to include mixed states (statistical ensembles of pure states). A pure state has density matrix $\rho = |\psi\rangle\langle\psi|$. A mixed state cannot be written as a single state vector and represents incomplete knowledge or entanglement with an external environment.$\rho = \rho^\dagger$$\text{Tr}(\rho) = 1$$|\psi\rangle$$\rho = |\psi\rangle\langle\psi|$$\…

Dicke state

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
Dicke state Dicke state is a symmetric superposition of all $n$-qubit computational basis states with exactly $k$ qubits in the $|1\rangle$ state. Dicke states generalize W states (the special case $k=1$) and are resources for quantum metrology and quantum error correction.$n$$D_n^{(k)}$$$D_n^{(k)} = \frac{1}{\sqrt{\binom{n}{k}}} \sum_{\text{all states with } k \text{ ones}} |x_1 x_2 \cdots x_n\rangle$$$\binom{n}{k}$$D_3^{(1)}$$\frac{1}{\sqrt{3}}(|100\rangle + |010\rangle + |001\rangle)$$D_3^{(…

Entanglement

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Entanglement Entanglement is a quantum correlation between two or more qubits such that the combined state cannot be written as a product of independent qubit states. An entangled state exhibits non-local correlations: measuring one qubit instantly affects the measured outcome probabilities of distant qubits, even if no signal travels between them.$|\psi\rangle$$|\psi\rangle = |\psi_A\rangle \otimes |\psi_B\rangle$$|\Phi^+\rangle = \frac{1}{\sqrt{2}}(|00\rangle + |11\rangle)$$\frac{1}{\sqrt{2}}…

Fidelity and purity

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Fidelity and purity Fidelity $F(\rho, \sigma)$ quantifies how close two quantum states are. For pure states $|\psi\rangle$ and $|\phi\rangle$, fidelity is $F = |\langle\psi|\phi\rangle|^2$, the squared overlap. For mixed states, fidelity is $F(\rho, \sigma) = \text{Tr}(\sqrt{\sqrt{\rho}\sigma\sqrt{\rho}})^2$, ranging from 0 (orthogonal) to 1 (identical). Interpretation * Fidelity 1: states are identical$> 1/2$$P = \text{Tr}(\rho^2)$$P = 1$$|\psi\rangle$$P = 1/2$$I/2$$P \in (1/2, 1)$$|\psi\ra…

GHZ state

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
GHZ state GHZ state $|GHZ\rangle = \frac{1}{\sqrt{2}}(|000\rangle + |111\rangle)$ is a three-qubit maximally entangled state. A generalization of the Bell state to three qubits, it exhibits global entanglement where no qubit can be separated as independent of the others. Representation: GHZ state has two basis components with equal amplitude and zero amplitude for all others: $$|GHZ\rangle = \frac{1}{\sqrt{2}}(|000\rangle + |111\rangle)$$$Z_1 Z_2$$Z_2 Z_3$$X_1 X_2 X_3$$H \otimes I \otimes I$$|…

Graph state

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Graph state Graph state is a multi-qubit entangled state defined on an arbitrary graph structure, where each qubit corresponds to a vertex and entanglement is imposed via CZ gates on edges. Graph states generalize cluster states and are the resource for measurement-based quantum computing.$G = (V, E)$$|+\rangle$$\text{CZ}_{i,j}$$(i, j) \in E$$G$$i$$$S_i = X_i \prod_{j \sim i} Z_j$$$j$$i$$+1$$|+\rangle$

Maximally entangled state

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Maximally entangled state Maximally entangled state (or Bell state generalization, $\Phi_d$) is a multi-qubit or multi-level state with maximum entanglement entropy between subsystems. For $n$ qubits, maximally entangled states achieve the upper bound on entanglement for their dimension, representing perfect correlation despite perfect mixedness from single-subsystem perspective.$n$$$|\Phi_d\rangle = \frac{1}{\sqrt{d}} \sum_{x=0}^{d-1} |x\rangle_A \otimes |x\rangle_B$$$d$$d = 2^n$$\log_2(2) = 1…

Minus-i state (|-i⟩)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Minus-i state (|-i⟩) Minus-i state $|-i\rangle$ is the -1 eigenstate of the Pauli Y operator. An equal superposition of $|0\rangle$ and $|1\rangle$ with a relative phase of $-i$, it is one of the four Pauli eigenstates. Representation: $|-i\rangle = \frac{1}{\sqrt{2}}(|0\rangle - i|1\rangle) = \frac{1}{\sqrt{2}} \begin{pmatrix} 1 \\ -i \end{pmatrix}$ Properties * Eigenstate of Y with eigenvalue -1: $Y|-i\rangle = -|-i\rangle$$|+i\rangle$$\langle -i|+i\rangle = 0$$\langle -i|-i\rangle = 1$$P…

Minus state (|-⟩)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Minus state (|-⟩) Minus state $|-\rangle$ is an equal superposition of $|0\rangle$ and $|1\rangle$ with a relative phase of -1. The -1 eigenstate of the Pauli X operator, it is used in phase-dependent quantum protocols and error correction. Representation: $|-\rangle = \frac{1}{\sqrt{2}}(|0\rangle - |1\rangle) = \frac{1}{\sqrt{2}} \begin{pmatrix} 1 \\ -1 \end{pmatrix}$ Properties * Eigenstate of X with eigenvalue -1: $X|-\rangle = -|-\rangle$$|+\rangle$$\langle -|+\rangle = 0$$\langle -|-\r…

Multi-Qubit entangled states (n-qubit general)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Multi-Qubit entangled states (n-qubit general) Multi-qubit entangled states generalize entanglement to arbitrary numbers of qubits ($n \geq 3$). This page covers general $n$-qubit entanglement structures; for three-qubit specific patterns, see three-qubit entangled states. Overview of general n-qubit states $k$$n$$n$$d$$n$$|0\rangle^{\otimes n}$$|+\rangle^{\otimes n}$$O(n)$$n$$O(n)$$O(n^2)$$n$$2^n$

Pauli eigenstates

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Pauli eigenstates Pauli eigenstates are the +1 and -1 eigenstates of the three Pauli operators X, Y, Z. Each Pauli has two orthogonal eigenstates spanning the two-dimensional single-qubit Hilbert space. Z basis (computational) Eigenstates of the Pauli Z operator:$Z|0\rangle = |0\rangle$$Z|1\rangle = -|1\rangle$$X|+\rangle = |+\rangle$$|+\rangle = \frac{1}{\sqrt{2}}(|0\rangle + |1\rangle)$$X|-\rangle = -|-\rangle$$|-\rangle = \frac{1}{\sqrt{2}}(|0\rangle - |1\rangle)$$Y|+i\rangle = |+i\rangle$…

Plus-i state (|+i⟩)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Plus-i state (|+i⟩) Plus-i state $|+i\rangle$ is the +1 eigenstate of the Pauli Y operator. An equal superposition of $|0\rangle$ and $|1\rangle$ with a relative phase of $+i$, it is one of the four Pauli eigenstates. Representation: $|+i\rangle = \frac{1}{\sqrt{2}}(|0\rangle + i|1\rangle) = \frac{1}{\sqrt{2}} \begin{pmatrix} 1 \\ i \end{pmatrix}$ Properties * Eigenstate of Y with eigenvalue +1: $Y|+i\rangle = |+i\rangle$$|-i\rangle$$\langle +i|-i\rangle = 0$$\langle +i|+i\rangle = 1$$P(0) …

Plus state (|+⟩)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Plus state (|+⟩) Plus state $|+\rangle$ is an equal superposition of $|0\rangle$ and $|1\rangle$. The +1 eigenstate of the Pauli X operator, it is fundamental for creating superposition and is used in nearly every quantum algorithm. Representation: $|+\rangle = \frac{1}{\sqrt{2}}(|0\rangle + |1\rangle) = \frac{1}{\sqrt{2}} \begin{pmatrix} 1 \\ 1 \end{pmatrix}$ Properties * Eigenstate of X with eigenvalue +1: $X|+\rangle = |+\rangle$$|-\rangle$$\langle +|-\rangle = 0$$\langle +|+\rangle = 1$…

Single-Qubit states

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
Single-Qubit states Single-qubit states are quantum states of a single qubit, normalized vectors in a two-dimensional Hilbert space. All single-qubit states can be represented on the Bloch sphere and are characterized by two real parameters (polar angles). Overview $|0\rangle$$|1\rangle$$|+\rangle$$|-\rangle$$|\psi\rangle = \alpha|0\rangle + \beta|1\rangle$$|\alpha|^2 + |\beta|^2 = 1$$$|\psi\rangle = \cos(\theta/2)|0\rangle + e^{i\phi}\sin(\theta/2)|1\rangle$$$\theta \in [0, \pi]$$|0\rangle$$|…

Stabilizer states

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Stabilizer states Stabilizer state is a quantum state defined as the +1 eigenstate of a set of commuting Pauli operators called stabilizers. Stabilizer formalism is the mathematical foundation for understanding quantum error correction, and stabilizer states can be efficiently simulated classically.$|\psi\rangle$$S_1, S_2, \ldots, S_k$$S_i|\psi\rangle = |\psi\rangle$$i$$G = \langle S_1, \ldots, S_k \rangle$$|0\rangle$$Z|0\rangle = |0\rangle$$|+\rangle$$X|+\rangle = |+\rangle$$|\Phi^+\rangle = \…

Superposition

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Superposition Superposition is the quantum principle that a qubit can exist in a linear combination of basis states simultaneously. Unlike a classical bit forced into a definite 0 or 1, a quantum qubit occupies a weighted sum of states until measured.$|\psi\rangle = \alpha|0\rangle + \beta|1\rangle$$\alpha$$\beta$$|\alpha|^2 + |\beta|^2 = 1$$|\alpha|^2$$|\beta|^2$$|\alpha|^2$$|\beta|^2$$n$$|s\rangle = \frac{1}{\sqrt{2^n}} \sum_{x=0}^{2^n-1} |x\rangle$$H|0\rangle = \frac{1}{\sqrt{2}}(|0\rangle +…

Three-Qubit entangled states

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
Three-Qubit entangled states Three-qubit entangled states are fundamental examples of multi-qubit entanglement, exhibiting global correlations that cannot be reduced to two-qubit interactions. Three qubits represent the smallest system showing genuinely multi-partite entanglement, with distinct entanglement classes and rich measurement properties.$\frac{1}{\sqrt{2}}(|000\rangle + |111\rangle)$$\frac{1}{\sqrt{3}}(|100\rangle + |010\rangle + |001\rangle)$$\frac{1}{\sqrt{2}}(|000\rangle + |111\ran…

State tomography

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
State tomography State tomography is an experimental procedure to reconstruct the quantum state $\rho$ of a system by performing many measurements in different bases and using classical processing to infer the state from outcome statistics. Principle Measuring a qubit multiple times in the same basis gives outcome probabilities but not the quantum state itself. Measuring in the Z basis yields probabilities for $|0\rangle$$|1\rangle$$|+\rangle$$|-\rangle$$S^\dagger H$$n$$3^n$$n$

Two-Qubit states

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Two-Qubit states Two-qubit states are quantum states of two qubits, normalized vectors in a four-dimensional Hilbert space. Two-qubit states are fundamental to understanding entanglement and form the basis for many quantum algorithms and protocols. $2 \times 2 = 4$$$|\psi\rangle = |\psi\rangle_A \otimes |\phi\rangle_B$$$|00\rangle$$|01\rangle$$|10\rangle$$|11\rangle$$\rho$$$\rho = \sum_i p_i \rho_i^A \otimes \rho_i^B$$$p_i \geq 0$$\sum_i p_i = 1$$i$$|\Phi^+\rangle$$|00\rangle$$\frac{1}{\sqrt{2}…

W state

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
W state W state $|W\rangle = \frac{1}{\sqrt{3}}(|001\rangle + |010\rangle + |100\rangle)$ is a three-qubit maximally entangled state where the entanglement is distributed evenly. Unlike the GHZ state, the W state is robust to loss of a single qubit. Representation: W state has three equal-amplitude basis components: $$|W\rangle = \frac{1}{\sqrt{3}}(|001\rangle + |010\rangle + |100\rangle)$$ Each term has exactly one qubit in state $|1\rangle$$|0\rangle$$|1\rangle$$|001\rangle$$|1\rangle$$1/3$…

Quantum state

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Quantum state Quantum states describe the complete information content of a quantum system. Like classical bits, qubits occupy definite states; unlike classical bits, qubits can exist in superposition—a linear combination of basis states. A quantum state of $n$$|\psi\rangle$$\mathbb{C}^{2^n}$$\langle\psi|\psi\rangle = 1$$|\psi\rangle = \alpha|0\rangle + \beta|1\rangle$$|\alpha|^2 + |\beta|^2 = 1$

Quantum Computing article writing guide

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Quantum Computing article writing guide Writing conventions for quantum computing topics (gates, states, algorithms, concepts). Article structure * Opening paragraph: bold term, 2–3 sentence definition, context and importance * Definition: mathematical formalism, matrix representation (for gates/states)$n$$|j\rangle$$j$$n$$n$

Qubit gate

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Qubit gate Simulation In C99, a header is provided that implements complex numbers. State As we'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…

Qubit

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Qubit Qubit (or quantum bit) is the basic unit of quantum information. The Hilbert space of a single qubit is $\mathbb{C}^2$, meaning two complex amplitudes to describe it, not one. A classical bit can only be 0 or 1. A qubit can be in a superposition: a combination of $\lvert 0\rangle$$\lvert 1\rangle$$$\lvert\psi\rangle = \begin{pmatrix}a\\b\end{pmatrix} = a\underbrace{\begin{pmatrix}1\\ 0\end{pmatrix}}_{\lvert 0\rangle} + b\underbrace{\begin{pmatrix}0\\1\end{pmatrix}}_{\lvert 1\rangle} = a\…

QuEra Computing

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
QuEra Computing QuEra Computing spun out of research at Harvard and MIT. Like Atom Computing, it builds on Neutral Atom qubits: rubidium atoms in optical tweezer arrays, with Rydberg-state excitation driving two-qubit gates. Its particular focus is reconfigurable geometry, since tweezers can be rearranged between circuit layers to match whatever connectivity an algorithm needs.

Queue

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Queue A queue is a first-in, first-out (FIFO) sequence. Elements are added at the back (enqueue) and removed from the front (dequeue). A queue can be implemented over a Linked list with a head and tail pointer, over a Circular buffer for a bounded version, or as a lock-free queue for concurrent use.

Queuing theory

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Queuing theory Queuing theory is the mathematical study of waiting lines, predicting queue length, wait time, and system behavior given arrival rate $\lambda$ and service rate $\mu$. The utilization ratio $\rho = \lambda/\mu$ must stay below 1 for stability, but queue length $L = \rho/(1-\rho)$ diverges nonlinearly—at 90% utilization, the queue is roughly 9 times longer than at 50%.

Collapse operators

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Collapse operators Collapse operators are synonymous with Lindblad operators—they're the quantum jumps that model irreversible evolution. The name comes from the Monte Carlo trajectory interpretation: each collapse operator represents a possible “jump” (measurement outcome or dissipative event) the system can undergo.$\sigma_- = \frac{1}{\sqrt{2}}(s_x + is_y)$$\sigma_z$$\sqrt{\kappa} a$$a$$\sqrt{\gamma} \sigma_-$$\sqrt{\gamma} \sigma_-$$\sqrt{\dot{n}} a^\dagger$

Quantum correlations

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Quantum correlations Quantum correlations describe how measurements on different parts of a system are correlated. Beyond entanglement, correlations include classical correlations (knowable information) and quantum discord (information that's quantum-mechanical only).$g^{(2)}(\tau) = \langle a^\dagger a^\dagger a a \rangle(t) / (\langle a^\dagger a \rangle^2)$$g^{(2)} \approx 1$$g^{(2)} < 1$$g^{(3)}$$g^{(4)}$$a^\dagger a^\dagger a a$

Decoherence and dissipation

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Decoherence and dissipation Decoherence is the loss of quantum coherence due to environmental interactions. Dissipation is the loss of energy. Both are modeled via collapse operators in the master equation. Types of decoherence Energy relaxation (T1 decay): Spontaneous emission of energy to the environment.$L = \sqrt{\gamma_1} \sigma_-$$T_1$$L = \sqrt{\gamma_{\phi}} \sigma_z$$T_2^* < T_1$$(\vert 0 \rangle + |1\rangle)/\sqrt{2}$$T_2 = 2 T_1$$T_2 < 2T_1$

Entanglement measures

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Entanglement measures Entanglement quantifies quantum correlations—whether a state is separable (product of individual states) or genuinely multi-body. QuTiP provides entanglement entropy, concurrence, and related measures. Entanglement entropy $S_A = -\text{Tr}(\rho_A \log_2 \rho_A)$$S_A = \log_2(d_A)$$C \in [0, 1]$$C = 1$$C = 0$

Expectation values

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Expectation values Expectation values are the measurable quantities from quantum simulations. For an observable $O$ and state $\rho$, the expectation is $\langle O \rangle = \text{Tr}(O\rho)$. All quantum measurements (Stern-Gerlach, photon counting, etc.) yield statistics described by expectation values.$\sigma_z = |0\rangle\langle 0| - |1\rangle\langle 1|$$|1\rangle\langle 1| = (1 - \sigma_z)/2$$\sigma_- = |0\rangle\langle 1|$$\sigma_+ = |1\rangle\langle 0|$$a^\dagger a$$X = (a + a^\dagger)/\…

Fidelity and metrics

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Fidelity and metrics Fidelity measures how close two quantum states (or unitaries) are. For states $\rho$ and $\sigma$: $$F(\rho, \sigma) = \text{Tr}(\sqrt{\sqrt{\rho} \sigma \sqrt{\rho}})$$ For pure states, this simplifies to $F = |\langle\psi|\phi\rangle|^2$. Fidelity ranges from 0 (orthogonal) to 1 (identical). from qutip import * import numpy as np # Two quantum states psi1 = basis(2, 0) psi2 = (basis(2, 0) + basis(2, 1)).unit() rho1 = psi1 * psi1.dag() rho2 = psi2 * psi2.dag() # Fide…

Lindblad operators

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Lindblad operators Lindblad operators (also called jump operators or collapse operators) specify the decay channels in the master equation. Each $L_k$ models one physical process: energy loss, dephasing, spontaneous emission, etc. A Lindblad operator is any operator $L_k$. Its effectiveness is controlled by a rate $\gamma_k$$L = \sigma_- = \begin{pmatrix} 0 & 0 \\ 1 & 0 \end{pmatrix}$$L = \sigma_z = \begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix}$$L = \sigma_x = \begin{pmatrix} 0 & 1 \\ 1 & 0 \e…

Master equation

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Master equation Master equation is the fundamental differential equation governing open quantum systems. It describes how the density matrix $\rho(t)$ evolves when the system is coupled to an environment: $$\frac{d\rho}{dt} = -\frac{i}{\hbar}[H, \rho] + \mathcal{D}[\rho]$$ The first term is unitary (Hamiltonian evolution); the second is the $L_k$$$\mathcal{D}[\rho] = \sum_k \left( L_k \rho L_k^\dagger - \frac{1}{2} \{L_k^\dagger L_k, \rho\} \right)$$$L_k$$\rho$

Mcsolve (monte carlo trajectories)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Mcsolve (monte carlo trajectories) Mcsolve runs stochastic trajectories of quantum evolution, applying collapse operators at random times. Each trajectory is a possible quantum history; averaging over many trajectories gives the ensemble result (matching mesolve). Monte Carlo simulations are useful for understanding how noise manifests at the individual-event level and for systems where many collapse operators dominate.$$H_{\text{eff}} = H - \frac{i\hbar}{2} \sum_k L_k^\dagger L_k$$$p_k(dt)$$L…

Mesolve (master equation solver)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Mesolve (master equation solver) Mesolve is QuTiP's main solver for the master equation. Given a Hamiltonian, collapse operators, initial state, and time points, it integrates the Lindblad equation and returns the state or expectation values at each time. Mesolve uses adaptive ODE solvers (IDA, dopri5) for efficiency and accuracy. It handles large systems (up to hundreds of qubits for classical simulation) and time-dependent Hamiltonians.

Open quantum systems

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Open quantum systems Open quantum systems are quantum systems coupled to an environment (a reservoir or bath). Unlike isolated systems (unitary evolution), open systems evolve non-unitarily: they lose information to the environment through decoherence and dissipation.

Optimal control

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Optimal control Optimal control designs time-dependent pulses to drive a quantum system to a target state while minimizing error and control cost. QuTiP's CRAB (Chopped RAndomBasis) algorithm finds near-optimal pulse shapes. Given Hamiltonian $H(t)$ with time-dependent control fields, find $u(t)$

Partial trace

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Partial trace Partial trace computes the reduced density matrix of a subsystem by tracing out others. For a composite system $AB$, the reduced state is $\rho_A = \text{Tr}_B(\rho_{AB})$. Partial trace is essential for analyzing entanglement and correlations in multi-qubit systems. It removes information about one subsystem, leaving only the observable statistics of the other.$n$$i, j, \ldots$

Pulse shaping

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Pulse shaping Pulse shaping designs smooth time-dependent control fields to minimize errors and off-resonant effects. Common pulse shapes: Gaussian, STIRAP, DRAG. DRAG pulses DRAG (Derivative Removal by Adiabatic Gate) reduces leakage errors in two-qubit gates:$$u(t) = \Omega(t) + i \beta \frac{d\Omega}{dt} \sigma_x$$$\Omega(t)$$\beta$

Quantum gates in qutip

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Quantum gates in qutip Quantum gates in QuTiP are unitary operators (or approximately unitary after time evolution). QuTiP provides built-in gates and methods to construct custom gates. Built-in single-qubit gates from qutip import * # Pauli gates X = sigmax() Y = sigmay() Z = sigmaz() # Hadamard H = hadamard_transform() # Phase gates S = phasegate(np.pi/2) T = phasegate(np.pi/4) # Rotations Rx = rx(np.pi/4) # Rotate π/4 around x Ry = ry(np.pi/2) # Rotate π/2 around y Rz = rz(np.pi/3…

Quantum objects (qobj)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Quantum objects (qobj) Quantum objects (Qobj) are the fundamental data structure in QuTiP, representing quantum states (kets, density matrices) and operators (Hamiltonians, measurement operators). A Qobj stores a matrix and metadata: dimensions, shape, and whether it's a ket, bra, operator, or superoperator.

Steady states

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Steady states Steady state is the long-time limit of an open quantum system: $\rho_{\text{ss}}$ where $d\rho_{\text{ss}}/dt = 0$. The steady state satisfies the master equation with zero time derivative, making it the fixed point of open system dynamics. For dissipative systems (non-Hermitian effective Hamiltonian), the steady state is unique and stable. All trajectories converge to it. For conservative systems (no decay), the steady state may not exist.$\rho_{\text{ss}}$

Superoperators

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Superoperators Superoperators (or supermatrices) are linear operators acting on density matrices (or vectorized density matrices). They generalize unitary operators: while unitaries preserve trace and positivity only for some operations, superoperators are general linear maps.$$\frac{d\rho}{dt} = \mathcal{L}[\rho]$$$\mathcal{L}$$$\mathcal{L}[\rho] = -\frac{i}{\hbar}[H, \rho] + \sum_k \left( L_k \rho L_k^\dagger - \frac{1}{2}\{L_k^\dagger L_k, \rho\}\right)$$$|\rho\rangle\rangle = \text{vec}(\rh…

Time evolution

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Time evolution Time evolution solves the master equation to get the system state at future times. QuTiP provides multiple solvers, each suited to different problems. Mesolve: master equation solver Mesolve is the standard solver for deterministic (ensemble-averaged) evolution. It integrates the master equation using efficient ODE solvers.

State visualization

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
State visualization State visualization displays quantum states and operators for understanding and debugging. QuTiP provides plotting functions for populations, densities, Wigner functions, and more. Populations and occupations Plot populations (diagonal elements of density matrix):

QuTiP

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T18:16:25+00:00
QuTiP QuTiP (Quantum Toolbox in Python) is an open-source Python library for simulating the dynamics of open quantum systems. Model decoherence, dissipation, and environmental effects via the master equation; evolve quantum states in time; compute entanglement and correlations. Used in cavity QED, superconducting qubits, trapped ions, and quantum optics.

Rotation gates (CUDA-Q)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Rotation gates (CUDA-Q) Rotation gates implementation using CUDA-Q. The example applies $R_x(\pi/2)$ to $\lvert 0\rangle$, producing $\frac{1}{\sqrt{2}}(\lvert 0\rangle - i\lvert 1\rangle)$. // Compile: nvq++ main.cpp -o main // Run: ./main #include #include struct kernel { __qpu__ void operator()() { cudaq::qubit q; rx(M_PI / 2.0, q); // R_x(pi/2) on |0> mz(q); } }; int main() { auto counts = cudaq::sample(kernel{}); counts.du…

Rotation gates (cuStateVec)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Rotation gates (cuStateVec) Rotation gates implementation using cuStateVec. The example applies $R_x(\pi/2)$ to $\lvert 0\rangle$, producing $\frac{1}{\sqrt{2}}(\lvert 0\rangle - i\lvert 1\rangle)$. // Compile: nvcc main.cu -o main -lcustatevec // Run: ./main #include #include #include #include int main() { const int nQubits = 1; const int dim = 1 << nQubits; cuDoubleComplex h_sv[2] = {{1,0},{0,0}}; // |0> cuDoubleComp…

Rotation gates (Qiskit)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Rotation gates (Qiskit) Rotation gates implementation using Qiskit. The example applies $R_x(\pi/2)$ to $\lvert 0\rangle$, producing $\frac{1}{\sqrt{2}}(\lvert 0\rangle - i\lvert 1\rangle)$. from qiskit import QuantumCircuit from qiskit.quantum_info import Statevector import numpy as np qc = QuantumCircuit(1) qc.rx(np.pi / 2, 0) # R_x(pi/2) on |0> print(Statevector(qc)) # Statevector([0.70710678+0.j, 0. -0.70710678j], dims=(2,))

Rabi oscillations

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
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…

Ramsey interferometry

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
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'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…

RCU

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
RCU RCU (Read-Copy-Update) is a synchronization scheme where readers access shared data with zero locking overhead, while writers copy the data, modify the copy, and atomically swap a pointer. Readers that held the old pointer before the swap continue using stale but valid data. The writer waits for a grace period—until all readers that could have seen the old pointer have finished—before freeing it.

RDMA

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
RDMA RDMA (Remote Direct Memory Access) lets one machine read or write another machine's memory directly over an interconnect without involving the remote CPU or kernel. Memory must be registered with the network adapter first, and one-sided operations (RDMA_WRITE, RDMA_READ) complete without remote software involvement.

Red-black tree

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Red-black tree A red-black tree is a self-balancing binary search tree that maintains O(log n) height through a set of colour invariants enforced on every insert and delete. Each node is coloured red or black, and the invariants constrain how colours can be arranged: the root is black, red nodes can only have black children, and every path from any node to a descendant NULL leaf passes through the same number of black nodes. These rules together bound the height to at most $2 \log_2(n+1)$

$\rho_0$ (Zero state density matrix)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
$\rho_0$ (Zero state density matrix) is the density matrix of the zero state. As a pure state its density matrix carries no more information than the ket, but the density matrix representation is the right starting point for studying what happens to $\lvert 0\rangle$ when it couples to an environment — when the ket description breaks down.$$\rho_0 = \lvert 0\rangle\langle 0\rvert = \begin{pmatrix}1\\0\end{pmatrix}\begin{pmatrix}1 & 0\end{pmatrix} = \begin{pmatrix}1 & 0\\0 & 0\end{pmatrix}$$$\l…

Rigetti Computing

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Rigetti Computing Rigetti Computing builds on Transmon qubits, the same family as IBM quantum and Google quantum AI. It fabricates its chips at its own facility, Fab-1, rather than through an external foundry, giving it direct control over the fabrication process. It also builds multi-chip systems that link separate processors together, scaling qubit count by combining smaller chips instead of betting on ever-larger single dies.

Roofline model

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Roofline model Roofline model is a visual performance model that plots kernel performance against arithmetic intensity to determine whether execution is limited by compute throughput or memory bandwidth. The model produces a roof-shaped curve with a diagonal slope (memory-bound region) meeting a flat ceiling (compute-bound region) at the ridge point.

Rotation gates

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
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 Using $e^{-i\theta P/2} = \cos(\theta/2)I - i\sin(\theta/2)P$ (which follows from $P^2 = I$ for any…

Ruin theory (personal finance)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
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'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're play…

Rotating wave approximation

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
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…

Rx gate

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Rx gate gate rotates a qubit by angle $\theta$ about the $x$-axis of the Bloch sphere. It is one of the three rotation gates and is defined as the matrix exponential of the Pauli-X operator: $$R_x(\theta) = e^{-i\theta X/2} = \begin{pmatrix}\cos\dfrac{\theta}{2} & -i\sin\dfrac{\theta}{2}\\[6pt] -i\sin\dfrac{\theta}{2} & \cos\dfrac{\theta}{2}\end{pmatrix}$$ Applied to the computational basis states: $$R_x(\theta)\lvert 0\rangle = \cos\tfrac{\theta}{2}\lvert 0\rangle - i\sin\tfrac{\theta}{2}\…

Ry gate

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Ry gate gate rotates a qubit by angle $\theta$ about the $y$-axis of the Bloch sphere. It is one of the three rotation gates and is defined as the matrix exponential of the Pauli-Y operator: $$R_y(\theta) = e^{-i\theta Y/2} = \begin{pmatrix}\cos\dfrac{\theta}{2} & -\sin\dfrac{\theta}{2}\\[6pt] \sin\dfrac{\theta}{2} & \cos\dfrac{\theta}{2}\end{pmatrix}$$ Applied to the computational basis states: $$R_y(\theta)\lvert 0\rangle = \cos\tfrac{\theta}{2}\lvert 0\rangle + \sin\tfrac{\theta}{2}\lver…

Rz gate

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Rz gate gate rotates a qubit by angle $\theta$ about the $z$-axis of the Bloch sphere. It is one of the three rotation gates and is defined as the matrix exponential of the Pauli-Z operator: $$R_z(\theta) = e^{-i\theta Z/2} = \begin{pmatrix}e^{-i\theta/2} & 0\\[6pt] 0 & e^{i\theta/2}\end{pmatrix}$$ Applied to the computational basis states: $$R_z(\theta)\lvert 0\rangle = e^{-i\theta/2}\lvert 0\rangle \qquad R_z(\theta)\lvert 1\rangle = e^{i\theta/2}\lvert 1\rangle$$ The gate is diagonal — …

S gate

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
S gate S gate (or gate) is a single-qubit gate that adds a phase of $\pi/2$ to the $\lvert 1\rangle$ state while leaving $\lvert 0\rangle$ unchanged. It is a special case of the phase gate with $\phi = \pi/2$, and satisfies $S^2 = Z$. $$S = \begin{pmatrix}1 & 0\\ 0 & i\end{pmatrix}$$ On the computational basis, $S\lvert 0\rangle = \lvert 0\rangle$ and $S\lvert 1\rangle = i\lvert 1\rangle$. On the Bloch sphere, $S$ is a $\pi/2$ rotation about the $z$-axis; it maps $\lvert +\rangle$$\lvert +i\…

SAXPY

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
SAXPY SAXPY (Scalar Alpha X Plus Y) is a fundamental HPC operation: $\mathbf{y} = a\mathbf{x} + \mathbf{y}$ where $a$ is a scalar and $\mathbf{x}$, $\mathbf{y}$ are vectors. It's embarrassingly parallel—each element can be updated independently—making it a canonical benchmark for measuring parallel overhead.

Schrödinger equation (QuTiP)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Schrödinger equation (QuTiP) Schrödinger equation implementation using QuTiP. QuTiP's sesolve() (schrödinger equation solver) integrates the equation directly in state-vector form. It takes the Hamiltonian H, an initial ket psi0, and a time array tlist, then returns a list of ket vectors $\lvert\psi(t)\rangle$$$i\hbar\frac{\mathrm{d}}{\mathrm{d}t}\lvert\psi\rangle = H\lvert\psi\rangle$$$\langle O\rangle = \langle\psi(t)\lvert O\lvert\psi(t)\rangle$

Schrödinger equation

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Schrödinger equation The Schrödinger equation is the equation of motion for a quantum state. In the qubit picture the state is a complex vector $\lvert\psi\rangle$ in a Hilbert space, and the equation is a first-order linear ODE on that vector. The generator of the evolution is a Hermitian operator $H$$$i\hbar\frac{\mathrm{d}}{\mathrm{d}t}\lvert\psi\rangle = H\lvert\psi\rangle$$$\lvert\psi\rangle$$t + dt$$t$$$\lvert\psi(t+dt)\rangle = U(t+dt,\,t)\,\lvert\psi(t)\rangle$$$dt$$U(t,t) = I$$U(t+dt, …

AC stark shift

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
AC stark shift AC Stark shift (or light shift) is the frequency shift of a qubit when driven by an off-resonant microwave pulse. The shift depends on detuning $\delta = \omega_{\text{drive}} - \omega_{\text{qubit}}$ and drive strength $\Omega$ (Rabi frequency). For weak driving: $$\Delta \omega_{\text{Stark}} \approx \frac{\Omega^2}{4\delta}$$ The shift is proportional to drive power and inversely proportional to detuning.$|2\rangle$

Anharmonicity

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Anharmonicity Anharmonicity (or nonlinearity) is the difference between transition frequencies: $\alpha = \omega_{12} - \omega_{01}$ (in energy units). For a transmon, anharmonicity is negative ($\alpha < 0$): $f_{12} < f_{01}$ due to the cosine potential which gets flatter near $\phi = \pi$. Anharmonicity enables selective qubit control: you can address the $0 \to 1$$1 \to 2$$|\alpha|$$|\alpha|$$\alpha \sim -100$$-300$$|\alpha| > 1$

Charge qubits

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Charge qubits Charge qubit (also Cooper pair box) is a Josephson junction shunted by a capacitor, without additional filtering inductors. The Hamiltonian is: $$H = 4E_C (\hat{n} - n_g)^2 - E_J \cos(\hat{\phi})$$ where $n_g = C V_g / (2e)$ is the offset charge controlled by a gate voltage $V_g$. Charge qubits are exquisitely sensitive to gate voltage—the energy levels shift dramatically with $n_g$$\delta n_g$$e$

Circuit quantization

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Circuit quantization Circuit quantization derives the quantum Hamiltonian from a classical superconducting circuit. Start with the circuit diagram (nodes, components), identify the generalized coordinates (node fluxes, charges), write the classical Lagrangian, then apply quantization rules: $\phi \to \hat{\phi}$$Q \to \hat{Q}$$[\hat{\phi}, \hat{Q}] = i\hbar$$\hat{H}$

Couplings and interactions

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Couplings and interactions Couplings describe how multiple qubits interact. Common coupling mechanisms: * Capacitive coupling: two qubits share a capacitor, Hamiltonian contains $\propto Q_1 Q_2$ terms * Inductive coupling: qubits share an inductor, Hamiltonian contains $\propto \phi_1 \phi_2$$g$$g$$g \sim 1$$100$$\sim 10$$100$

Dispersive shifts

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Dispersive shifts Dispersive shift is the frequency shift of one qubit when another qubit changes state. In coupled qubits, the interaction Hamiltonian causes energy shifts dependent on the state of the coupled qubit. For capacitively coupled transmons with coupling $g_{12} n_1 n_2$$$\Delta \omega_1 = 2 g_{12} |\alpha|$$$\alpha$$\alpha$

Eigenspectra and energy levels

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Eigenspectra and energy levels Eigenspectra are the set of energy levels and eigenstates of the qubit Hamiltonian. For a transmon, the lowest two energy levels define the computational qubit; higher levels represent leakage states. from scqubits import Transmon transmon = Transmon(EJ=15.0, EC=0.3, ncut=30) # Eigenvalues (energies) evals = transmon.eigenvals(n=10) # First 10 levels print(evals) # Eigenvectors (states) evecs = transmon.eigenvecs(n=5) # Energy differences (transition freque…

Fluxoniums

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T18:17:50+00:00
Fluxoniums Fluxonium is a superconducting qubit with stronger nonlinearity than transmons. It combines a Josephson junction with an L-C oscillator in series. Fluxoniums are flux-tunable (controlled by applied magnetic flux), compact, and exhibit strong anharmonicity—useful for fast, robust gates.$$H = 4E_C \hat{n}^2 + E_L (\hat{\phi} - \Phi_{\text{ext}}/\Phi_0)^2 - E_J \cos(\hat{\phi})$$$E_L$$\Phi_{\text{ext}}$$\Phi_0$

Hamiltonian construction

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Hamiltonian construction Hamiltonian construction in scqubits involves specifying the qubit type and parameters, then scqubits automatically computes the quantum Hamiltonian. For standard qubits (transmon, fluxonium, etc.), this is automatic. For custom circuits, you can build composite Hamiltonians from qubit objects.

Hierarchy and composite systems

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Hierarchy and composite systems Hierarchy in scqubits refers to building composite systems from individual qubits. The HilbertSpace class combines multiple qubit objects and adds interactions. from scqubits import Transmon, Fluxonium, HilbertSpace, InteractionTerm # Create qubits q1 = Transmon(EJ=15.0, EC=0.3, ncut=30, label='q1') q2 = Transmon(EJ=15.0, EC=0.3, ncut=30, label='q2') q3 = Fluxonium(EJ=12.0, EC=2.5, EL=0.5, ncut=30, label='q3') # Create hilbert space hilbert = HilbertSpace([q1…

Hilbert space truncation

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Hilbert space truncation Hilbert space truncation is the finite approximation to an infinite Hilbert space. Each qubit is embedded in a harmonic oscillator Hilbert space (charge or phase basis) with infinite dimension. Numerically, we truncate to a finite cutoff: $n_{\text{cut}}$$|0\rangle, |1\rangle, \ldots, |n_{\text{cut}}\rangle$$n_{\text{cut}}$$n^3$$n_{\text{cut}}$$n_{\text{cut}} \sim 30–50$

Noise and decoherence

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Noise and decoherence Noise causes decoherence—the loss of quantum information. Main noise sources in superconducting qubits: * Charge noise: fluctuations in gate voltage or offset charge ($\delta n_g$). Causes dephasing. Transmons reduce charge noise sensitivity via the $E_J \gg E_C$$\propto 1/f$$|1\rangle \to |0\rangle$

Numerical methods

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Numerical methods Numerical methods in scqubits compute eigenvalues and eigenvectors, matrix elements, and other properties. Main methods: Diagonalization: construct the Hamiltonian matrix, compute eigendecomposition via LAPACK/scipy. Works for systems up to ~1000×1000.

Parameter optimization

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Parameter optimization Parameter optimization finds qubit design parameters that maximize a figure of merit (high frequency, strong anharmonicity, long coherence, etc.). from scqubits import Transmon from scipy.optimize import minimize # Target: maximize anharmonicity def objective(params): EJ, EC = params transmon = Transmon(EJ=EJ, EC=EC, ncut=30) alpha = transmon.anharmonicity() return -alpha # Minimize negative alpha # Initial guess x0 = [15.0, 0.3] # Optimize result = …

Parameter sweeps

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Parameter sweeps Parameter sweeps compute qubit properties (frequencies, anharmonicity, matrix elements) as a function of design parameters. Useful for optimizing qubit design and understanding parameter sensitivity. from scqubits import Transmon, Fluxonium import numpy as np import matplotlib.pyplot as plt # Sweep EJ EJ_values = np.linspace(10, 30, 50) f_01_values = [] anh_values = [] for EJ in EJ_values: transmon = Transmon(EJ=EJ, EC=0.3, ncut=30) f_01_values.append(transmon.f_01(…

Phase qubits

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Phase qubits Phase qubit is a Josephson junction biased near the maximum of its potential energy, operating in the regime where tunneling through the barrier matters. The potential $-E_J \cos(\phi)$ has a barrier near $\phi = \pi$. Phase qubits are less commonly used today but historically important (Delft, Yale experiments). They exhibit strong nonlinearity and can be read via quasiparticle escape over the potential barrier.$\phi = \pi$$|1\rangle$

Superconducting qubits

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Superconducting qubits Superconducting qubits are two-level quantum systems built from superconducting circuits—Josephson junctions and capacitors. A Josephson junction is a tunnel junction between two superconductors separated by a thin insulator; it exhibits nonlinear inductance and can act as a nonlinear resonator.$\omega_0 / \gamma$$\gamma$

Transition frequencies

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Transition frequencies Transition frequencies are energy differences between levels: $\omega_{i \to j} = (E_j - E_i) / \hbar$. The qubit frequency is $\omega_{01} = (E_1 - E_0) / \hbar$. For a transmon, the qubit frequency is approximately: $$\omega_{01} \approx \sqrt{8 E_J E_C} - E_C$$ (first-order approximation in $E_C / E_J$). from scqubits import Transmon import numpy as np transmon = Transmon(EJ=15.0, EC=0.3, ncut=30) # Qubit frequency f_01 = transmon.f_01() # GHz print(f"Qubit fre…

Transmons

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T18:17:45+00:00
Transmons Transmon (transmission line shunted plasma oscillation qubit) is the most common superconducting qubit design. It consists of a Josephson junction shunted (paralleled) by a large capacitor. The capacitor reduces charge noise sensitivity compared to bare charge qubits, making transmons robust and practical.$$H = 4E_C \hat{n}^2 - E_J \cos(\hat{\phi})$$$\hat{n}$$E_C$$E_J$$\hat{\phi}$$E_J / E_C$

Plotting and visualization

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Plotting and visualization Visualization in scqubits includes energy level diagrams, parameter sweeps, and state representations. from scqubits import Transmon import matplotlib.pyplot as plt transmon = Transmon(EJ=15.0, EC=0.3, ncut=30) # Energy level diagram fig, ax = plt.subplots() evals = transmon.eigenvals(n=6) ax.hlines(evals, 0, 1, colors='b') for i, E in enumerate(evals): ax.text(1.05, E, f'|{i}⟩', va='center') ax.set_xlim(0, 1.5) ax.set_ylabel('Energy (GHz)') ax.set_title('Tran…

scqubits

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T18:19:18+00:00
scqubits scqubits is a Python library for designing and analyzing superconducting qubit systems. Simulate circuit quantization for transmons, fluxoniums, and custom circuits; compute eigenspectra and transition frequencies; model couplings and parameter sweeps; study anharmonicity and dispersive shifts. Used for hardware design, qubit characterization, and optimizing circuit parameters.

Semaphore

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Semaphore Semaphore is a synchronization primitive. It'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.

Shell advanced features

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Shell advanced features Indexed arrays Arrays store multiple values in a single variable. Declare with arr=(val1 val2 val3) or assign individual elements. # Declare array colors=("red" "green" "blue") # Access by index (zero-based) echo ${colors[0]} # Output: red echo ${colors[2]} # Output: blue # Assign individual elements colors[3]="yellow" # Get all elements echo ${colors[@]} # Output: red green blue yellow # Get array length echo ${#colors[@]} # Output: 4 # Iterate over a…

Shell shell-basics

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Shell shell-basics Variables Variables store values. Assign with VAR=value (no spaces around =). Access with $VAR or ${VAR}. Variables are case-sensitive and untyped—everything is a string unless used in arithmetic. $ NAME="Alice" $ echo $NAME # prints: Alice $ echo ${NAME}_suffix # prints: Alice_suffix $ X=5; Y=$((X + 3)); echo $Y # arithmetic: prints 8

Shell best practices

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
Shell best practices Script structure Start with a shebang line and safety flags. Use clear variable names, proper quoting, and functions to organize code. #!/bin/bash set -e -u -o pipefail # Script configuration readonly SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" readonly DATA_FILE="$SCRIPT_DIR/data.txt" # Main function main() { if [[ $# -lt 1 ]]; then usage exit 1 fi local input="$1" process_input "$input" } # Helper function process_…

Shell shell-control-flow

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Shell shell-control-flow Conditionals Conditionals run commands based on conditions. Use if to test exit codes or use [[ ... ]] for test expressions. Common operators: -f (file exists), -z (string empty), -n (string non-empty), = or == (string equal),

Shell file operations

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Shell file operations File tests Use conditional tests to check file properties. These tests are most readable within [[ ]] conditionals. # Test existence and type [[ -f /etc/passwd ]] && echo "Regular file exists" [[ -d /home ]] && echo "Directory exists" [[ -L /etc/default ]] && echo "Symbolic link exists" [[ -b /dev/sda ]] && echo "Block device exists" # Test permissions and attributes [[ -r /etc/passwd ]] && echo "File is readable" [[ -w /tmp ]] &&…

Shell functions

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
Shell functions Functions Define reusable code blocks with the function keyword or parentheses syntax. Functions reduce code duplication and improve readability. # Both syntaxes are equivalent function greet() { echo "Hello, $1!" } greet_alt() { echo "Hello, $1!" } # Call the function greet "Alice"

Shell I/O and redirection

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
Shell I/O and redirection Redirection Redirect standard input, output, and error between files and file descriptors. File descriptor 1 is stdout, 2 is stderr, 0 is stdin. * >: Write stdout to file (truncates if exists) * >>: Append stdout to file

Shell processes

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
Shell processes Background and foreground Run commands in the background by appending & to allow the shell prompt to return immediately. Use fg and bg to move jobs between foreground and background. # Run in background (shell returns immediately) long_running_task & # List all jobs jobs # Bring last job to foreground fg # Bring specific job to foreground (e.g., job 1) fg %1 # Resume a suspended job in background bg # Run command and get its PID curl http://example.com & echo $! # Print…

Shell

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Shell Shell is a command interpreter that lets you run programs and orchestrate them. Type commands in the terminal, chain programs via pipes, redirect input/output, and run jobs in the background. The shell parses what you type, finds the program, passes arguments, and handles environment variables.

Shor's algorithm

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Shor's algorithm Shor'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 \…

Qubit gates

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Qubit gates Qubit gates (single-qubit gates) are $2 \times 2$ unitary matrices that act on a single Qubit. Every such gate corresponds to a rotation on the Bloch sphere. The most general single-qubit gate (up to global phase) is the U gate $U(\theta, \phi, \lambda)$, which spans all of $SU(2)$; every named single-qubit gate is a special case of it.$I$$X$$Y$$Z$$\pi$$x$$y$$z$$X$$\lvert 0\rangle \leftrightarrow \lvert 1\rangle$$Z$$\lvert 0\rangle$$\lvert 1\rangle$$Y = iXZ$$X^2 = Y^2 = Z^2 = I$$Z$$…

SMP

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
SMP SMP (Symmetric Multiprocessing) describes a system where multiple identical cores share a single main memory and OS instance, with every core equally capable of running any task. The OS scheduler treats all cores interchangeably. “Symmetric”

The compact symplectic group $Sp(n)$

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
The compact symplectic group $Sp(n)$ The compact symplectic group $Sp(n)$ is the group of length-preserving linear transformations of $n$-dimensional quaternionic space. In one line, $$Sp(n)=\{A\in M_n(\mathbb H):A^*A=I\}.$$ This looks like the familiar definition $O(n)=\{A\in M_n(\mathbb R):A^TA=I\}$, except that the entries are quaternions and $A^*$$Sp(n)$$4n\times4n$$Sp(n)$$USp(2n)$$Sp(2n,\mathbb R)$$$q=a+bi+cj+dk,\qquad a,b,c,d\in\mathbb R,$$$$i^2=j^2=k^2=ijk=-1.$$$ij=k$$ji=-k$$$\bar q=a-…

Spinlock

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Spinlock Spinlock is a lock where a thread that fails to acquire it busy-waits in a tight loop, repeatedly retrying an atomic test-and-set, instead of yielding to the OS scheduler. Spinning avoids context-switch overhead, making spinlocks cheap when the critical section is short, but burns CPU cycles when contention is high.

SSH agent

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
SSH agent SSH agent holds your private keys in memory, decrypted, so you don't need to type your passphrase every time. Once a key is added to the agent, any SSH command can use it without prompting. Start the agent: $ eval "$(ssh-agent -s)" This sets

SSH authentication

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
SSH authentication SSH authentication verifies your identity to the remote server. The protocol supports multiple methods, tried in a configurable order. Public-key authentication (using Ed25519 or RSA keys) is the standard; passwords are now considered legacy.

SSH basics

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
SSH basics SSH (Secure Shell) is a protocol for secure remote access. Connect with ssh user@host or ssh host (uses current username). SSH encrypts all traffic and authenticates both client and server. $ ssh user@hostname # connect to remote host $ ssh user@192.168.1.100 # connect via IP address $ ssh hostname "command" # run command remotely and exit $ ssh -v user@host # verbose output (debugging) $ exit # disconnect from remote …

SSH configuration

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
SSH configuration SSH configuration files control connection defaults and options. The main file is ~/.ssh/config, which lets you define host aliases, authentication options, and forwarding rules without typing them on every command. Basic syntax:

SSH copy and sync

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
SSH copy and sync SCP (Secure Copy) and rsync transfer files over SSH. SCP is simpler for one-time copies; rsync is better for syncing because it skips unchanged files and can resume interrupted transfers. SCP basics: $ scp file user@host:/path # copy file to remote $ scp user@host:/path/file . # copy from remote $ scp -r dir user@host:/path # copy directory recursively $ scp -P 2222 file user@host:/path # use non-standard port (note: -P not -p)

SSH jump hosts

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
SSH jump hosts Jump hosts (bastion hosts) allow you to access servers on private networks by chaining through an intermediate public-facing host. SSH can do this transparently. Single jump: $ ssh -J jumphost user@finalhost SSH connects to jumphost

SSH key generation

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
SSH key generation Generate a key pair with ssh-keygen. Modern standard is Ed25519 (fast, secure, small keys). Older RSA keys are also supported but larger. $ ssh-keygen -t ed25519 -C "user@host" $ ssh-keygen -t rsa -b 4096 -C "user@host" # older standard

SSH multiplexing

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
SSH multiplexing Connection multiplexing lets multiple SSH commands and shells reuse a single connection, avoiding the overhead of establishing new connections repeatedly. Configure in ~/.ssh/config: Host * ControlMaster auto ControlPath ~/.ssh/socket-%r@%h:%p ControlPersist 10m

SSH port forwarding

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
SSH port forwarding Port forwarding secures connections by tunneling local or remote ports through SSH. Useful for accessing services behind firewalls or across untrusted networks. Local forward: traffic from your localhost goes through SSH to a service on the remote side.

SSH security

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
SSH security SSH security depends on key management, file permissions, and thoughtful server configuration. Follow best practices to prevent unauthorized access. Key generation and storage: * Use Ed25519 keys (modern, fast, 256-bit security): ssh-keygen -t ed25519 -C "user@host"

SSH server configuration

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
SSH server configuration SSH server configuration is controlled by sshd_config. Edit /etc/ssh/sshd_config, test syntax, then restart the service. Key security settings: Port 22 # SSH port (consider 2222 for less noise) PermitRootLogin no # disable root login PubkeyAuthentication yes # allow public-key auth PasswordAuthentication no # disable password auth (use keys) ChallengeResponseAuthentication no X11Forwarding no # di…

SSH troubleshooting

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
SSH troubleshooting SSH connection issues usually come from permissions, wrong keys, host key mismatches, or firewalls. Debug with verbose output and check logs. Enable verbose output: $ ssh -vvv user@host Shows protocol details, key matching, and error messages. Three

SSH

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
SSH SSH (Secure Shell) lets you securely connect to remote computers and run commands. Authentication uses passwords or public-key cryptography. Transfer files securely with scp or rsync. Tunnel arbitrary traffic through SSH connections for security and access through firewalls.

Stack

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Stack A stack is a last-in, first-out (LIFO) sequence. The only accessible element is the top; you push to add and pop to remove, always at the same end. A stack can be implemented over an Array (with a top index) or a Linked list (with insertions at the head). The array-backed version is more cache-friendly; the linked version avoids a fixed capacity.

State vector

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
State vector State vector (written as ket $\lvert\psi\rangle$) 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,…

Strunk & white

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Strunk & white Strunk & 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.

SWAP gate (CUDA-Q)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
SWAP gate (CUDA-Q) SWAP gate implementation using CUDA-Q. The example prepares $\lvert 10\rangle$ and applies SWAP to produce $\lvert 01\rangle$. // Compile: nvq++ main.cpp -o main // Run: ./main #include struct kernel { __qpu__ void operator()() { cudaq::qvector<2> q; x(q[0]); // q[0]=|1>, q[1]=|0> => |10> swap(q[0], q[1]); // |10> -> |01> mz(q); } }; int main() { auto counts = cudaq::sample(kernel{}); counts.dump(); …

SWAP gate (cuStateVec)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
SWAP gate (cuStateVec) SWAP gate implementation using cuStateVec. The example prepares $\lvert 10\rangle$ and applies SWAP to produce $\lvert 01\rangle$. // Compile: nvcc main.cu -o main -lcustatevec // Run: ./main #include #include #include int main() { const int nQubits = 2; const int dim = 1 << nQubits; // Prepare |10>: q0=1, q1=0 -> index 2 (binary 10) cuDoubleComplex h_sv[4] = {0}; h_sv[2] = make_cuDoubleComplex(1.0, 0.…

SWAP gate (Qiskit)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
SWAP gate (Qiskit) SWAP gate implementation using Qiskit. The example prepares $\lvert 10\rangle$ and applies SWAP to produce $\lvert 01\rangle$. from qiskit import QuantumCircuit from qiskit.quantum_info import Statevector qc = QuantumCircuit(2) qc.x(1) # q0=|0>, q1=|1> => |10> in math ordering qc.swap(0, 1) # |10> -> |01> print(Statevector(qc)) # Statevector([0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j], dims=(2, 2))

SWAP gate

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
SWAP gate SWAP gate is a two-qubit gate that exchanges the states of its two qubits. It is symmetric — neither qubit plays the role of control or target — and it is its own inverse: $\text{SWAP}^2 = I$. $$\text{SWAP} = \begin{pmatrix}1&0&0&0\\ 0&0&1&0\\ 0&1&0&0\\ 0&0&0&1\end{pmatrix}$$ $$\text{SWAP}\lvert 00\rangle = \lvert 00\rangle \qquad \text{SWAP}\lvert 01\rangle = \lvert 10\rangle \qquad \text{SWAP}\lvert 10\rangle = \lvert 01\rangle \qquad \text{SWAP}\lvert 11\rangle = \lvert 11\rangle…

CSP

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
CSP CSP (Communicating Sequential Processes) is a concurrency model where independent processes coordinate purely through message passing over channels, with no shared memory. Send and receive operations are synchronous (rendezvous): the sender and receiver synchronize at the point of communication.

Linda

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Linda Linda is a coordination model using a shared tuple space where processes write and read tuples matching patterns, decoupling producers from consumers in both space and time. Unlike CSP, there is no direct addressing; all interaction goes through the shared associative memory.

Mailbox

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Mailbox Mailbox is a bounded, addressed message queue: one process sends into it, another consumes from it in FIFO order. Unlike CSP channels (anonymous rendezvous) or Linda (addressed by content), mailboxes are owned by a specific recipient and provide natural backpressure when full.

Monitor

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Monitor Monitor is a synchronization primitive combining a mutex with condition variables, allowing a thread to wait for a condition while holding a lock and be woken by another thread. This structured pattern avoids deadlocks compared to separate mutexes and semaphores.

Mutex

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Mutex Mutex (mutual exclusion lock) allows only one thread to hold it at a time; other threads block until the owner unlocks. A mutex enforces ownership: only the locking thread may unlock, protecting against bugs where the wrong thread releases it.

Semaphore

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Semaphore Semaphore is a counter protecting access to shared resources, manipulated by atomic wait (decrements, blocks if negative) and signal (increments, wakes a blocked thread). A counting semaphore initialized to N allows up to N concurrent holders; a

Synchronization primitive

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Synchronization primitive Synchronization primitive is a mechanism for coordinating access to shared state between concurrent threads or processes, preventing race conditions. Primitives split into mutual exclusion (e.g., Mutex), which ensures only one thread accesses data at a time, and

Syntax origin

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Syntax origin Nothing on the syntax page is one language. Four independent parsers contribute to this wiki, and knowing which one owns a construct is usually what explains its quirks. When two of them claim the same characters, DokuWiki connects syntax modes in ascending

Wiki syntax

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Wiki syntax This wiki runs DokuWiki with the markdowku plugin on top, so both DokuWiki markup and Markdown work in the same page, often interchangeably. Math is handled by KaTeX and LaTeX figures by texrender. Where the two markups overlap, this page shows both and says which one to prefer. Everything below was checked against this installation. The differences from stock DokuWiki are real, not theoretical.$\begin{pmatrix}1\\0\end{pmatrix}$$\begin{pmatrix}0\\1\end{pmatrix}$$e^{i\pi} + 1 = 0$$$…

T gate

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
T gate T gate (or gate, or gate) is a single-qubit gate that adds a phase of $\pi/4$ to the $\lvert 1\rangle$ state while leaving $\lvert 0\rangle$ unchanged. It is a special case of the phase gate with $\phi = \pi/4$, and is the square root of the S gate: $T^2 = S$. $$T = \begin{pmatrix}1 & 0\\ 0 & e^{i\pi/4}\end{pmatrix}$$ On the computational basis, $T\lvert 0\rangle = \lvert 0\rangle$ and $T\lvert 1\rangle = e^{i\pi/4}\lvert 1\rangle$. On the Bloch sphere, $T$ is a $\pi/4$ rotation abou…

Terminal

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
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…

TexLive basics

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
TexLive basics Every LaTeX document starts with \documentclass, which selects the document type (article, book, report). Then you open the document environment with \begin{document} and close it with \end{document}. Everything between those tags is your content; everything before (the preamble) defines packages, settings, and commands.

TexLive presentations

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
TexLive presentations Beamer is a document class for creating slide presentations in LaTeX. Use \documentclass{beamer} instead of article. \documentclass{beamer} \title{Presentation Title} \author{Author} \date{2026-08-19} \begin{document} \frame{\titlepage} \begin{frame} \frametitle{Slide Title} \begin{itemize} \item First point \item Second point \end{itemize} \end{frame} \begin{frame} \frametitle{Another Slide} Content here. \end{frame} \end{document}

TexLive compilers

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
TexLive compilers LaTeX has several compilers, each with different capabilities and output. The most common are pdflatex, xelatex, and lualatex. They all read .tex files and produce output (PDF by default). pdflatex is the standard compiler. It's fast, stable, and widely supported. It directly produces PDF output and is best for most documents.

TexLive debugging

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
TexLive debugging LaTeX compilation errors stop the compile and display a message. Read the .log file or terminal output for line numbers and error messages. Common errors and fixes: Undefined control sequence — you used a command that doesn't exist. Check spelling (

TexLive documents

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
TexLive documents Document class is the first line in every LaTeX file and sets the document type. The three standard classes are article (for papers and short documents), book (for long documents with chapters), and report (for reports and theses). Each class defines default margins, font sizes, section hierarchy, and spacing.

TexLive figures

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
TexLive figures Including images requires the graphicx package. Use \includegraphics{filename} to embed a PNG, JPG, or PDF file. \usepackage{graphicx} \begin{document} \includegraphics{diagram.png} \includegraphics[width=8cm]{diagram.png} \includegraphics[height=5cm, width=8cm]{diagram.png} \end{document}

TexLive formatting

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
TexLive formatting Text styling is done with commands like \textbf{bold}, \textit{italic}, \emph{emphasis}, and \underline{underline}. \emph is context-aware—it produces italics normally but upright text inside italicized sections. Font sizes use

TexLive headers and footers

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
TexLive headers and footers Page headers and footers contain running titles, page numbers, and author names. The fancyhdr package provides flexible control over them. \usepackage{fancyhdr} \pagestyle{fancy} \lhead{Left Header} \chead{Center Header} \rhead{Right Header} \lfoot{Left Footer} \cfoot{\thepage} % page number \rfoot{Right Footer} \begin{document} % Page content \end{document}

TexLive installation

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
TexLive installation Install TexLive via your package manager. On Debian/Ubuntu, install the full distribution (TexLive plus all common packages) or a minimal set if disk space matters. sudo apt update sudo apt install texlive-full # ~3GB, includes everything

TexLive math

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
TexLive math Math mode in LaTeX allows rendering mathematical equations and symbols. Inline math uses $...$ or $...$ delimiters; display (block) math uses $$...$$ or \[...\]. Inside math mode, special commands render operators, Greek letters, fractions, subscripts, and more. Math mode is where LaTeX shines—fine control over spacing, alignment, and mathematical notation.$E = mc^2$$$\sum_{i=1}^{n} i = \frac{n(n+1)}{2}$$$\alpha, \beta, \gamma, \delta, \epsilon$$\frac{1}{2}$$\tfrac{1}{2}$$\sin(\t…

TexLive packages

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
TexLive packages Packages extend LaTeX with new commands and environments. Load them in the preamble (before \begin{document}) with \usepackage{packagename}. Packages add features like graphics, colors, advanced math, bibliographies, code listings, and much more.

TexLive references

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
TexLive references Cross-references link to sections, figures, tables, and equations using \label and \ref. Place \label{key} after a section heading, caption, or equation, then use \ref{key} or \eqref{key} (for equations) to insert its number. \section{Introduction} \label{sec:intro} In Section \ref{sec:intro}, we... \begin{equation} E = mc^2 \label{eq:einstein} \end{equation} From equation \eqref{eq:einstein}, we derived...

TexLive sections and lists

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
TexLive sections and lists Section hierarchy organizes documents. Articles use \section{Title} (level 1), \subsection{Title} (level 2), \subsubsection{Title} (level 3). Books add \chapter{Title} at level 0. Sections are automatically numbered and appear in the table of contents. Use the starred version

TexLive tables

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
TexLive tables Tables are created with the tabular environment. Columns are separated by &, rows by \\. The first argument specifies column alignment: l (left), c (center), r (right). \begin{tabular}{l c r} Left & Center & Right \\ A & B & C \\ 1 & 2 & 3 \end{tabular}

TexLive tikz graphics

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
TexLive tikz graphics TikZ is a powerful drawing package for creating diagrams, flowcharts, plots, and graphics programmatically. Load with \usepackage{tikz}. Drawings are created inside tikzpicture environments using commands that specify paths, shapes, and styling.

TexLive

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
TexLive TexLive is a LaTeX distribution for scientific and technical typesetting. Write markup in .tex files, compile to PDF with pdflatex or xelatex. Professional alternative to Word for papers, theses, and technical documentation—version-controllable, mathematically precise, cross-platform.

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
This is a small demonstration of inline TikZ graphics embedded directly inside ordinary text. A simple horizontal line can appear inside a sentence without requiring a separate figure. We can similarly draw a small arrow or an arrow in the opposite direction

TFLOPS

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
TFLOPS TFLOPS is FLOPS measured in units of $10^{12}$ (teraflops) floating-point operations per second, the scale at which modern GPUs and small clusters are quoted. A single high-end datacenter GPU exceeds tens of TFLOPS in FP64 and over a hundred TFLOPS in lower-precision formats used for machine learning.

ThinkPad

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
ThinkPad X-series x220ai

Three-qubit gates

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Three-qubit gates Three-qubit gates are $8 \times 8$ unitary matrices acting on a three-qubit system. They appear in fault-tolerant quantum computation and quantum arithmetic circuits. Any three-qubit gate decomposes into two-qubit and single-qubit gates, though the decompositions can be deep.$\lvert 1\rangle$$$\text{CCX}\lvert c_1 c_2 t\rangle = \lvert c_1 c_2\rangle \otimes \lvert t \oplus (c_1 \wedge c_2)\rangle$$$\lvert 1\rangle$$T$$T$$T^\dagger$$H$$S$$T$$T$$T$

Three qubits

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Three qubits Three-qubit system is a quantum system of three qubits. The Hilbert space is $\mathbb{C}^8$, meaning eight complex amplitudes to describe it, not three. A single qubit needs two amplitudes; two qubits need four; three qubits need eight. The state space doubles with every qubit you add. That exponential growth is what makes quantum computers interesting.$$\lvert\psi\rangle = \begin{pmatrix}c_{000}\\c_{001}\\c_{010}\\c_{011}\\c_{100}\\c_{101}\\c_{110}\\c_{111}\end{pmatrix}, \qquad \…

Tmux command mode

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Tmux command mode Command mode lets you type raw tmux commands to control sessions, windows, and panes. Enter command mode with Ctrl+B :, type a command, and press Enter. Ctrl+B : enter command mode Common commands: # Window management new-window -n name create window named "name" kill-window kill current window rename-window new-name rename current window # Pane management split-window -v split vertically (top/bottom)…

Tmux configuration

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Tmux configuration Configuration happens in ~/.tmux.conf. Tmux reads this file on startup. Reload it anytime without restarting tmux by running tmux source-file ~/.tmux.conf or pressing Ctrl+B :source-file ~/.tmux.conf in command mode. Common settings

Tmux copy mode

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Tmux copy mode Copy mode lets you select and copy text from the current pane buffer. Enter copy mode with Ctrl+B [, navigate with arrow keys or vim keys, select with Space, and copy with Enter. Basic workflow: Ctrl+B [ enter copy mode j/k down/up (if using vi keys) w/b next/previous word f/F/t/T jump to character / search forward ? search backward Space start selection Enter …

Tmux key bindings

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Tmux key bindings The prefix key (Ctrl+B by default) activates Tmux commands. Press it, release, then press the command. For example, Ctrl+B then c creates a new window. Change the prefix in ~/.tmux.conf with set-option -g prefix C-a. Common key bindings (prefix =

Tmux layouts

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Tmux layouts Layouts automatically arrange panes in a window according to a preset pattern. Cycle through layouts with Ctrl+B Space to find one that fits your workflow. Built-in layouts: even-horizontal panes arranged side-by-side, equal width even-vertical panes stacked vertically, equal height main-horizontal large main pane on top, smaller panes below main-vertical large main pane on left, smaller panes on right tiled fill window evenly, like a grid

Tmux panes

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Tmux panes Panes are splits within a window. You can split a window vertically (top/bottom) or horizontally (left/right), and nest splits arbitrarily. Each pane runs independently, though they share the same window and layout. Split and navigate panes with these key bindings (prefix =

Tmux plugins

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Tmux plugins Plugins extend tmux with additional functionality. They can add new key bindings, status bar enhancements, pane themes, and more. Plugins are shell scripts that hook into tmux's configuration. The easiest way to manage them is with a plugin manager like TPM (Tmux Plugin Manager).

Tmux scripting

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Tmux scripting Scripting with tmux lets you automate session setup. Launch sessions with tmux new-session, create windows with tmux new-window, and send commands with tmux send-keys. This is useful for project-specific startup routines. Basic session creation:

Tmux sessions

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Tmux sessions Sessions run in the background and can be detached and reattached. A session contains windows and persists even when you disconnect. This is useful for remote work—if your SSH connection drops, your session is still running. $ tmux # create a new unnamed session $ tmux new-session -s work # create named session $ tmux list-sessions # list all sessions $ tmux attach -t work # attach…

Tmux windows

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Tmux windows Windows are tabs within a session. Each window is independent but shares the session state. You can have multiple windows open, switch between them, and each window can contain panes. Create and manage windows with these commands: $ tmux new-window # create window in current session $ tmux new-window -n build # create window named "build" $ tmux list-windows # list windows in current session

Tmux

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Tmux Tmux is a terminal multiplexer that lets you run multiple terminals within one terminal. Create sessions that run in the background, create windows within sessions, and split windows into panes. Detach and reattach to sessions anytime—they keep running whether you're connected or not.

Toffoli gate (CUDA-Q)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Toffoli gate (CUDA-Q) Toffoli gate implementation using CUDA-Q. The example prepares $\lvert 110\rangle$ (both controls $\lvert 1\rangle$, target $\lvert 0\rangle$) and applies the Toffoli gate, flipping the target to produce $\lvert 111\rangle$. // Compile: nvq++ main.cpp -o main // Run: ./main #include struct kernel { __qpu__ void operator()() { cudaq::qvector<3> q; x(q[0]); // q[0] = |1> x(q[1]); …

Toffoli gate (cuStateVec)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Toffoli gate (cuStateVec) Toffoli gate implementation using cuStateVec. The example prepares $\lvert 110\rangle$ (both controls $\lvert 1\rangle$, target $\lvert 0\rangle$) and applies the Toffoli gate, flipping the target to produce $\lvert 111\rangle$. // Compile: nvcc main.cu -o main -lcustatevec // Run: ./main #include #include #include int main() { const int nQubits = 3; const int dim = 1 << nQubits; // Prepare |110>: q0=1, q1=…

Toffoli gate (Qiskit)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Toffoli gate (Qiskit) Toffoli gate implementation using Qiskit. The example prepares $\lvert 110\rangle$ (both controls $\lvert 1\rangle$, target $\lvert 0\rangle$) and applies the Toffoli gate, flipping the target to produce $\lvert 111\rangle$. from qiskit import QuantumCircuit from qiskit.quantum_info import Statevector qc = QuantumCircuit(3) qc.x(0) # q0 = |1> qc.x(1) # q1 = |1> => state is |110> qc.ccx(0, 1, 2) # Toffoli: both controls |1>, flip target -> |111> print(St…

Topics I plan to write about

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Topics I plan to write about Wikipedia * Trace theory * Pi calculus * History monoid Concepts * Hazard pointer * ABA problem * Cache coherence (MSI MESI MOESI DragonFly)

Topological qubits

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Topological qubits Topological qubits encode quantum information not in the local state of a single particle but in the global, topological configuration of a many-body system, typically the braiding history of quasiparticles called non-Abelian anyons. The leading candidate is the Majorana zero mode, a quasiparticle predicted to appear at the ends of a topological superconducting nanowire, where a pair of spatially separated Majorana modes together form one nonlocal qubit. Because the informati…

Trace monoid

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Trace monoid Trace monoid is an algebraic structure capturing concurrent computation—sequences of actions where swapping independent actions (those with no shared data) doesn't change the result. It's a partial order of instructions formalized as an equivalence class under commutativity of independent pairs, the algebraic foundation for analyzing concurrent program semantics.

Transmon qubits

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Transmon qubits Transmon qubits are superconducting qubits built from a Josephson junction shunted by a large capacitor. The capacitor suppresses the circuit's sensitivity to charge noise, which was the main limitation of the earlier Cooper pair box design. Transmons are the workhorse of most large-scale superconducting quantum processors today, including those from IBM and Google.$\lvert 0 \rangle$$\lvert 1 \rangle$$$H = 4 E_C (n - n_g)^2 - E_J \cos\varphi$$$E_C$$E_J$$n$$n_g$$\varphi$$E_J / E_…

Trapped ion qubits

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Trapped ion qubits Trapped ion qubits use individual ions, commonly ytterbium or calcium, confined by oscillating electric fields in a linear Paul trap and encode qubit states in stable internal atomic levels such as hyperfine ground states. Because the ions are held purely by electric fields and repel each other via Coulomb interaction, they form a rigid, self-assembling chain with no fabrication-induced disorder, giving this platform some of the longest coherence times and highest gate fideli…

Treiber stack

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Treiber stack Treiber stack (1986) is the simplest lock-free data structure, a singly-linked stack where push and pop both use compare-and-swap on the head pointer, retrying if contended. It demonstrates the CAS-retry pattern that appears everywhere in lock-free programming.

Two-qubit gates

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Two-qubit gates Two-qubit gates are $4 \times 4$ unitary matrices acting on a pair of qubits. Unlike single-qubit gates, they can create entanglement between qubits that were previously in a product state. Any two-qubit unitary can be decomposed into at most three $n$$\lvert +\rangle\lvert 0\rangle$$(c_x, c_y, c_z)$$\lvert 1\rangle$$\pi/2$

Two qubits

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Two qubits Two-qubit system is a quantum system of two qubits. The Hilbert space is $\mathbb{C}^4$, meaning four complex amplitudes to describe it, not two. A single qubit needs two amplitudes; two qubits need four; three qubits need eight. The state space doubles with every qubit you add. That exponential growth is what makes quantum computers interesting.$$\lvert\psi\rangle = \begin{pmatrix}c_{00}\\c_{01}\\c_{10}\\c_{11}\end{pmatrix}, \qquad \lvert\psi\rangle = c_{00}\underbrace{\begin{pmatr…

U gate (CUDA-Q)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
U gate (CUDA-Q) U gate implementation using CUDA-Q. The example applies $U(\pi/2, 0, \pi) = H$ to $\lvert 0\rangle$ via its Euler decomposition, producing $\lvert +\rangle$. // Compile: nvq++ main.cpp -o main // Run: ./main #include #include struct kernel { __qpu__ void operator()() { cudaq::qubit q; // U(theta, phi, lambda) via Euler decomposition: Rz(phi) Ry(theta) Rz(lambda) rz(0.0, q); // phi = 0 ry(M_PI / 2.0, q); …

U gate (cuStateVec)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
U gate (cuStateVec) U gate implementation using cuStateVec. The example applies $U(\pi/2, 0, \pi) = H$ to $\lvert 0\rangle$, producing $\lvert +\rangle$. // Compile: nvcc main.cu -o main -lcustatevec // Run: ./main #include #include #include #include int main() { const int nQubits = 1; const int dim = 1 << nQubits; cuDoubleComplex h_sv[2] = {{1,0},{0,0}}; // |0> cuDoubleComplex *d_sv; cudaMalloc(&d_sv, dim * sizeof…

U gate (Qiskit)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
U gate (Qiskit) U gate implementation using Qiskit. The example applies $U(\pi/2, 0, \pi) = H$ to $\lvert 0\rangle$, producing $\lvert +\rangle$. from qiskit import QuantumCircuit from qiskit.quantum_info import Statevector import numpy as np qc = QuantumCircuit(1) qc.u(np.pi / 2, 0, np.pi, 0) # U(pi/2, 0, pi) = H print(Statevector(qc)) # Statevector([0.70710678+0.j, 0.70710678+0.j], dims=(2,))

Unitary gate

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Unitary gate Unitary gate is the most general single-qubit unitary gate, parameterized by three real angles $\theta$, $\phi$, $\lambda$. Every single-qubit unitary (up to global phase) can be expressed as $U(\theta, \phi, \lambda)$ for some choice of these angles, making it the canonical representation of a single-qubit gate.$$U(\theta, \phi, \lambda) = \begin{pmatrix}\cos\dfrac{\theta}{2} & -e^{i\lambda}\sin\dfrac{\theta}{2}\\[8pt] e^{i\phi}\sin\dfrac{\theta}{2} & e^{i(\phi+\lambda)}\cos\dfrac…

Valgrind basics

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Valgrind basics Valgrind instruments your program to observe every memory access and instruction execution. Install via your package manager, compile with debug symbols, then run with valgrind. sudo apt install valgrind # Debian/Ubuntu sudo dnf install valgrind # Fedora/RHEL

Valgrind cachegrind

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Valgrind cachegrind cachegrind simulates CPU caches (L1 instruction, L1 data, L2, L3) and reports cache miss rates and memory behavior. Like callgrind, it counts deterministically without sampling. Use it to understand cache efficiency and validate optimization strategies.

Valgrind callgrind

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Valgrind callgrind callgrind is a profiling tool built on Valgrind's instrumentation engine. Unlike perf, which samples at fixed intervals, callgrind counts instructions deterministically—every instruction is counted. This gives reproducible results even for very short-running programs.

Valgrind DRD

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Valgrind DRD DRD (Detector of Runtime Data races) is an alternative to helgrind for detecting data races in multithreaded code. Like helgrind, it instruments memory accesses to find races, but it uses a different detection algorithm that's sometimes faster or catches different patterns.

Valgrind helgrind

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Valgrind helgrind helgrind detects data races and lock-ordering problems in multithreaded programs (pthreads, OpenMP). A data race occurs when two threads access the same memory location without synchronization—at least one is a write. Even if the race doesn't cause a visible crash, it's undefined behavior and a correctness bug.

Valgrind massif

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Valgrind massif massif profiles heap memory usage over time, showing how much memory is allocated at each point in the program. Use it to find memory leaks, optimize memory footprint, and identify allocation hotspots. valgrind --tool=massif ./program ms_print massif.out.12345

Valgrind memcheck

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Valgrind memcheck memcheck tracks every byte of memory and detects four main classes of error: invalid memory access (reading/writing past buffer bounds), use-after-free, uninitialized value usage, and memory leaks. It maintains shadow state for every allocation—whether each byte is initialized and whether it's still allocated.

Valgrind output

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Valgrind output Valgrind error reports include the error type, location (file and line), and stack trace. Learning to read them accurately is essential for debugging. A typical error report looks like: ==12345== Invalid read of size 4 ==12345== at 0x109179: process (program.c:22) ==12345== by 0x1091AB: main (program.c:31) ==12345== Address 0x4a4b080 is 0 bytes after a block of size 40 alloc'd ==12345== at 0x483DD99: malloc (vg_replace_malloc.c:307) ==12345== by 0x109150: proces…

Valgrind performance

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Valgrind performance Valgrind is slow: 10-50x slowdown is typical, sometimes worse. This is necessary to observe every instruction and memory access, but it limits what you can profile in practice. Strategic choices about what and how to run Valgrind can make it manageable.

Valgrind suppressions

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
Valgrind suppressions Suppression files tell Valgrind to ignore specific errors from system libraries, language runtimes, or trusted third-party code. They're necessary to reduce noise from false positives that you can't fix (e.g., intentional optimizations in libc that Valgrind can't understand).

Valgrind

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Valgrind Valgrind is a dynamic analysis framework that instruments your program to detect memory bugs, threading races, and performance issues. It runs your code on a synthetic CPU, observing every memory access and checking for errors: buffer overflows, use-after-free, memory leaks, uninitialized values, data races. Catches bugs at the moment they happen, not when they cause a crash elsewhere.

von neumann equation (qutip)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
von neumann equation (qutip) von Neumann equation implementation using QuTiP. QuTiP's mesolve() (master equation solver) integrates the Lindblad master equation. Passing an empty collapse-operator list c_ops=[] disables the dissipator, reducing it exactly to the von Neumann equation:$$\frac{\mathrm{d}\rho}{\mathrm{d}t} = -\frac{i}{\hbar}[H,\,\rho]$$$O$$\langle O\rangle = \mathrm{tr}(\rho\, O)$

von-Neumann equation

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
von-Neumann equation von-Neumann equation is basically the Schrodinger equation where the quantum state is represented by a density matrix $\rho$, rather than a state vector $\lvert\psi\rangle$. It takes the following form. $$\frac{\mathrm d\rho}{\mathrm dt} = -\frac{i}{\hbar}[H, \rho]$$ Where $H$ is the Hamiltonian and $\rho$ is the density matrix and they both vary in time. Meanwhile $i$$\hbar$$$\dot\rho = -\frac{i}{\hbar}[H, \rho]$$$[H, \rho]$$[H, \rho] = H\rho - \rho H$$$\dot\rho = -\frac…

VPS

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
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.

VQE

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
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…

W state (Qiskit)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
W state (Qiskit) W state implementation using Qiskit. The three-qubit W state $\lvert W\rangle = (\lvert 001\rangle + \lvert 010\rangle + \lvert 100\rangle)/\sqrt{3}$ is prepared using the recursive decomposition $\lvert W_3\rangle = \frac{1}{\sqrt{3}}\lvert 1\rangle\lvert 00\rangle + \sqrt{\frac{2}{3}}\lvert 0\rangle\lvert W_2\rangle$. import numpy as np from qiskit import QuantumCircuit from qiskit.quantum_info import Statevector qc = QuantumCircuit(3) # Step 1: ry on q[0] to set amplitud…

(WIP) work in progress

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
(WIP) work in progress

Writing guide on header files

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Writing guide on header files Writing guide on header files is a supplement to the writing guide specifically for articles about C and C++ header files. The goal of a header article is not to replicate documentation. cppreference and the POSIX manual pages already do that exhaustively. An article here should give a programmer a genuine understanding of the header: why it exists, how it feels to use it, what it gets wrong, and how the key parts are implemented under the hood.

Writing guide on parallel computing

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Writing guide on parallel computing Writing guide on parallel computing (this article) covers conventions specific to parallel computing articles in this wiki. Read the general writing guide first; this document supplements it. The central challenge Parallel computing articles fail in one consistent way: they explain what a primitive does before establishing why a C programmer would care. The reader lands on

Writing guide on quantum computing

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Writing guide on quantum computing Writing guide on quantum computing (this article) covers conventions specific to quantum computing articles in this wiki. Read General writing guide first for structure, paragraph, and code block conventions that apply across all articles.$H^\dagger = H$$(AB)^\dagger = B^\dagger A^\dagger$$\mathrm{tr}(ABC) = \mathrm{tr}(CAB)$$\lvert\psi\rangle$$\langle\psi\rvert$$\langle\phi\lvert\psi\rangle$$\lvert\psi\rangle\langle\psi\rvert$$H$$X$$Y$$Z$$\rho$$[A, B] = AB - …

WTI

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
WTI WTI (Write-Through Invalidate) is the simplest snoopy cache coherence protocol: every write goes directly to main memory, and all other caches invalidate their copy upon seeing the write. Only two states per line are needed: Valid (matches memory) and Invalid (stale).

X gate (CUDA-Q)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
X gate (CUDA-Q) X gate implementation using CUDA-Q. // Compile: nvq++ main.cpp -o main // Run: ./main #include struct kernel { __qpu__ void operator()() { cudaq::qubit q; x(q); // |0> -> |1> mz(q); } }; int main() { auto counts = cudaq::sample(kernel{}); counts.dump(); // 100% |1> }

X gate (cuStateVec)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
X gate (cuStateVec) X gate implementation using cuStateVec. // Compile: nvcc main.cu -o main -lcustatevec // Run: ./main #include #include #include int main() { const int nQubits = 1; const int dim = 1 << nQubits; cuDoubleComplex h_sv[2] = {{1,0},{0,0}}; // |0> cuDoubleComplex *d_sv; cudaMalloc(&d_sv, dim * sizeof(cuDoubleComplex)); cudaMemcpy(d_sv, h_sv, dim * sizeof(cuDoubleComplex), cudaMemcpyHostToDevice); cust…

X gate (Qiskit)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
X gate (Qiskit) X gate implementation using Qiskit. from qiskit import QuantumCircuit from qiskit.quantum_info import Statevector qc = QuantumCircuit(1) qc.x(0) # |0> -> |1> print(Statevector(qc)) # Statevector([0.+0.j, 1.+0.j], dims=(2,))

X gate

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
X gate X gate (or Pauli-X gate, or quantum NOT gate) is a single-qubit gate that flips $\lvert 0\rangle$ to $\lvert 1\rangle$ and $\lvert 1\rangle$ to $\lvert 0\rangle$, making it the quantum analog of a classical NOT gate. It is one of the three Pauli gates. $$X = \begin{pmatrix}0 & 1\\ 1 & 0\end{pmatrix}$$ The gate flips the computational basis states and leaves the Hadamard basis states ($\lvert +\rangle$$\lvert -\rangle$$$X\lvert 0\rangle = \lvert 1\rangle \qquad X\lvert 1\rangle = \lvert…

GPU rendering artifacts on thinkpad X220 with hyprland — diagnosis & fix

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T16:02:27+00:00
GPU rendering artifacts on thinkpad X220 with hyprland — diagnosis & fix Hardware & 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)

Xanadu

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Xanadu Xanadu, based in Toronto, builds on Photonic qubits, but with a different encoding than PsiQuantum: continuous-variable quantum information, stored in squeezed states of light rather than discrete qubit states. Its Borealis and X-series systems combine squeezed-light sources, programmable beamsplitter networks, and photon-number-resolving detectors on a chip.

Y gate (CUDA-Q)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Y gate (CUDA-Q) Y gate implementation using CUDA-Q. // Compile: nvq++ main.cpp -o main // Run: ./main #include struct kernel { __qpu__ void operator()() { cudaq::qubit q; y(q); // |0> -> i|1>; global phase not observable at measurement mz(q); } }; int main() { auto counts = cudaq::sample(kernel{}); counts.dump(); // 100% |1> }

Y gate (cuStateVec)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Y gate (cuStateVec) Y gate implementation using cuStateVec. // Compile: nvcc main.cu -o main -lcustatevec // Run: ./main #include #include #include int main() { const int nQubits = 1; const int dim = 1 << nQubits; cuDoubleComplex h_sv[2] = {{1,0},{0,0}}; // |0> cuDoubleComplex *d_sv; cudaMalloc(&d_sv, dim * sizeof(cuDoubleComplex)); cudaMemcpy(d_sv, h_sv, dim * sizeof(cuDoubleComplex), cudaMemcpyHostToDevice); cust…

Y gate (Qiskit)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Y gate (Qiskit) Y gate implementation using Qiskit. from qiskit import QuantumCircuit from qiskit.quantum_info import Statevector qc = QuantumCircuit(1) qc.y(0) # |0> -> i|1> print(Statevector(qc)) # Statevector([0.+0.j, 0.+1.j], dims=(2,))

Y gate

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Y gate Y gate (or Pauli-Y gate) is a single-qubit gate represented by the second Pauli matrix. It combines the actions of the X gate (bit flip) and the Z gate (phase flip), and additionally multiplies the amplitude by $i$. It is one of the three Pauli gates. $$Y = \begin{pmatrix}0 & -i \\ i & 0\end{pmatrix}$$ The gate maps the computational basis states with an accompanying imaginary factor, and its eigenstates are the $Y$$$Y\lvert 0\rangle = i\lvert 1\rangle \qquad Y\lvert 1\rangle = -i\lver…

Wiki

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
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'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.

Z gate (CUDA-Q)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:52+00:00
Z gate (CUDA-Q) Z gate implementation using CUDA-Q. The Z gate applied to $\lvert 0\rangle$ is invisible at measurement (it leaves $\lvert 0\rangle$ unchanged), so this example prepares $\lvert +\rangle$ first, applies Z, then rotates back to the computational basis to confirm the phase flip. // Compile: nvq++ main.cpp -o main // Run: ./main #include struct kernel { __qpu__ void operator()() { cudaq::qubit q; h(q); // |0> -> |+> z(q); // |+> -> |-…

Z gate (cuStateVec)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Z gate (cuStateVec) Z gate implementation using cuStateVec. The Z gate applied to $\lvert 0\rangle$ is invisible at measurement (it leaves $\lvert 0\rangle$ unchanged), so this example prepares $\lvert +\rangle$ first to make the phase flip observable via interference. // Compile: nvcc main.cu -o main -lcustatevec // Run: ./main #include #include #include #include int main() { const int nQubits = 1; const int dim = 1 << nQubits;…

Z gate (Qiskit)

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Z gate (Qiskit) Z gate implementation using Qiskit. The Z gate applied to $\lvert 0\rangle$ is invisible at measurement (it leaves $\lvert 0\rangle$ unchanged), so this example prepares $\lvert +\rangle$ first to make the phase flip observable via interference. from qiskit import QuantumCircuit from qiskit.quantum_info import Statevector qc = QuantumCircuit(1) qc.h(0) # |0> -> |+> qc.z(0) # |+> -> |-> print(Statevector(qc)) # Statevector([ 0.70710678+0.j, -0.70710678+0.j], dims=(2,))

Z gate

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
Z gate Z gate (or Pauli-Z gate, or phase flip gate) is a single-qubit gate that applies a phase flip to the $\lvert 1\rangle$ state while leaving $\lvert 0\rangle$ unchanged. It is the third Pauli gate and a special case of the phase gate with $\phi = \pi$. $$Z = \begin{pmatrix}1 & 0\\ 0 & -1\end{pmatrix}$$ The gate leaves the computational basis states $\lvert 0\rangle$ and $\lvert 1\rangle$ as eigenstates, and swaps the Hadamard basis states:$$Z\lvert 0\rangle = \lvert 0\rangle \qquad Z\lve…

ZH-calculus

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
ZH-calculus ZH-calculus extends ZX-calculus with a third generator, the H-box, which represents a Hadamard-like node whose entries can be arbitrary complex numbers rather than just $\pm 1$. This lets ZH-calculus directly express non-linear boolean functions (AND, Toffoli-style multi-controlled gates) as a single diagram element, something ZX-calculus can only build out of several spiders.$-1$

ZW-calculus

Anonymous (anonymous@undisclosed.example.com) — 2026-08-26T15:46:40+00:00
ZW-calculus ZW-calculus is a graphical language for quantum computation, closely related to ZX-calculus, built around a third kind of node (the W-spider) alongside the usual green Z-spider. It was introduced to natively represent the GHZ and W entangled states, two three-qubit states that are inequivalent under local operations but which ZX-calculus can only express clumsily.

ZX-calculus

Anonymous (anonymous@undisclosed.example.com) — 2026-08-22T15:22:28+00:00
ZX-calculus ZX-calculus is a graphical language for reasoning about quantum circuits, built from diagrams of green and red nodes connected by wires instead of matrix algebra. Each diagram represents a linear map, and two diagrams represent the same map if and only if one can be rewritten into the other using a small set of graphical rules. This turns circuit equivalence, normally a matter of multiplying unitary matrices, into diagram manipulation.