Co-distillation is the vaporization and collection of multiple components together during distillation. A component can enter the collected vapor alongside another volatile substance instead of being isolated as a pure vapor. Steam distillation is the case in which water supplies a volatile carrier; co-distillation is not restricted to water.

The result depends on vapor-liquid equilibrium. In an ideal, fully mixed binary liquid at a specified temperature, Raoult's law gives $p_A=x_A{p}_A^{\ast }$ and $p_B=x_B{p}_B^{\ast }$. The vapor fraction is $y_A=p_A/(p_A+p_B)$. The McMaster distillation manual uses liquid/vapor composition diagrams to explain why the vapor can be enriched in one component while still containing both.^[ref]

For original hypothetical data, let $x_A=0.25$, $p_A^{\ast }=80\mathrm{kPa}$ and $p_B^{\ast }=20\mathrm{kPa}$. Then $p_A=20$ and $p_B=15\mathrm{kPa}$, giving $y_A=20/35\approx 0.571$. Both components co-distil, but the vapor is richer in $A$ than the starting liquid. These are equilibrium pressures at the stated temperature; boiling additionally requires their sum to match the external pressure.

With two persistent immiscible liquid phases, a different limiting model uses the pure-component vapor pressures directly, rather than multiplying each by its fraction of a homogeneous mixture. An azeotrope is another special equilibrium situation. Specify the phase behavior before assigning a distillate composition, and use a distillation material balance to distinguish enrichment from total recovery. Collecting a component together with a carrier does not itself establish complete separation from every impurity.

A differential signal pair carries information in the electric potential difference between two conductors. For conductor potentials $V_{+}$ and $V_{-}$ relative to a stated reference, define the differential and common-mode voltage components byEquivalently $V_{+}=V_c+V_d/2$ and $V_{-}=V_c-V_d/2$. A signal pair need not have zero common component; the receiver uses the difference while tolerating a specified range of common input potentials.^[ref]

Equal added disturbances cancel in the ideal subtraction: replacing both potentials by $V_{\pm }+n$ leaves $V_d$ unchanged. For example, inputs at $1.8$ and $1.2$ volts have $V_d=0.6$ volts. Adding $0.2$ volts to each changes $V_c$ but preserves the difference.

Real receivers have finite common-mode rejection ratio, and unequal coupling or mismatched impedances can convert a common disturbance into a differential one. Thus differential signalling is a system property involving the source, both paths and the receiver. An original test applies the same disturbance to both inputs and compares the output with a deliberately unbalanced path; it separates ideal cancellation from sensitivity to mismatch.

Metamorphosis is a developmental transformation between substantially different life stages, such as a tadpole becoming a frog or a caterpillar becoming an adult butterfly. It can reorganize feeding structures, movement, habitat use and internal tissues, rather than merely increasing size. Regulated cell differentiation, tissue remodelling and cell death contribute to the transition.

An early experiment showed that feeding tadpoles thyroid tissue accelerated differentiation relative to comparison diets. ^[ref] The intervention connected a secretory organ to the timing of a whole-body transformation. It did not isolate a pure hormone or establish that growth and differentiation are the same process. Modern thyroid hormone biology explains this amphibian example; insect metamorphosis uses a different hormonal system.

A database management system is software that defines, stores, queries and updates databases while managing access, integrity and concurrent use. Its components can include a query parser, optimizer, storage manager, transaction manager and recovery mechanism. A database is the managed collection; the database management system supplies the mechanisms and interfaces used to operate on it.

For example, evaluating SELECT name FROM Person WHERE id = 7 requires interpreting the query, choosing an access path, retrieving visible records and returning the selected field. An index can speed the lookup without changing its logical result. Concurrent updates may require locks or versions, and a crash may require log replay. Merely writing records to a file does not supply those guarantees. PostgreSQL's tutorial illustrates the distinction between client applications, the server process managing database files and connections, and the databases accessed through that server.^[ref]

Data independence separates the logical meaning of stored data from details that an application need not know. Physical independence permits changing indexes, page layout or access paths without changing a query's meaning. Logical independence permits some changes in the database's logical organization while preserving the interface exposed to existing applications, often through views.

For example, a query asking for an employee's department should return the same answer after the database replaces a table scan with a B-tree index. An application that follows stored record addresses directly would instead depend on that representation. E. F. Codd's1970 relational model explicitly argued against dependencies on ordering, indexes and access paths.^[ref] Independence does not mean every schema change is invisible: removing a field an application needs changes its contract unless another representation supplies equivalent information.

A database view is a named database query that can be used much like a database relation. An ordinary view stores the query definition rather than a separate persistent copy of its result. Referring to the view evaluates that definition as part of the surrounding database query; changes in the underlying data can therefore change the view's result.^[ref]

For example, an orders table might contain identifiers, totals and payment flags. The definition CREATE VIEW unpaid_orders AS SELECT id, total FROM orders WHERE paid = false; exposes the unpaid orders without requiring every application query to repeat the condition. If order 17 is marked paid, the next query of the ordinary view no longer includes that order, subject to the query's database transaction snapshot. Creating the view did not create another independent copy of order 17.

A view can hide storage and schema details behind a stable interface, supporting data independence. A materialized view instead stores results that require a refresh policy. Some ordinary views permit updates, but a view containing aggregation or certain joins may not identify a unique underlying row to change. Update behavior and access control are separate specifications; the word view alone does not guarantee that an arbitrary definition is writable or supplies a security boundary.^[ref]

A digital-to-analog converter maps a digital code to a physical analog output, usually an electric potential difference or electric current. For an ideal unipolar $N$-bit voltage-output converter with reference $V_{\mathrm{ref}}$, one common convention isIts step is $\Delta =V_{\mathrm{ref}}/2^N$ and its highest code produces $V_{\mathrm{ref}}-\Delta$, not the reference itself. Endpoint conventions differ between devices.

A three-bit converter with a 1 V reference gives levels $0,0.125,\dots ,0.875$ V. Sweeping the code slowly and measuring each settled level tests offset, gain and unequal step sizes. Rapid code changes add settling and transient errors. Holding each output until the next update creates a staircase; reconstructing a smooth waveform also requires suitable filtering and a sampling rate compatible with its bandwidth. Finite levels impose quantization even before analog noise and nonlinearity are considered.^[ref]

LZ77 is a family of lossless source coding methods that replace repeated data by references to previously decoded data in a sliding window. A reference specifies a backward distance and a match length; unmatched symbols are emitted literally. Some formulations additionally attach a following literal to each match, so the exact token format belongs to the particular codec.

For example, encode abcabcabc as literal abc followed by distance3,length6. Decoding copies sequentially from three positions behind the current output. The source and destination overlap: the first copied abc becomes available for the second copy. Copying the referenced region as one fixed pre-existing array slice would therefore be incorrect. DEFLATE combines LZ77-style matches with Huffman coding and explicitly allows overlapping references.^[ref] A match finder and a token-cost model determine which repetitions are profitable; a longer textual match is not automatically the cheapest encoded choice.

Low-side current sensing places a sensor between a load and its return reference. For a shunt resistor, the electric potential difference across the shunt resistor is proportional to the returning electric current. The readout inputs can operate near the return potential, but the load's local return is raised by the burden voltage. High-side current sensing instead places the sensor toward the supply.^[ref]

For an illustrative12volt supply, a6ohm load and a50milliohm return-path shunt resistor, Ohm's law givesThe load return is about99millivolts above the source return, and the load itself receives about11.901volts. These potentials matter if a second instrument or communication cable connects the load return to another reference. A parallel return path can bypass the shunt resistor, so the measured branch electric current need not equal the total load electric current.

Pete Semig's reference design provides a concrete apparatus: a25ohm shunt resistor, an instrumentation amplifier and a single5volt supply measure a specified range from10microamperes to10milliamperes. Its circuit analysis and simulated responses separate the ideal current-to-output relation from practical offset and low-current errors.^[ref]

For a new setup, recording a zero-current output and several known electric currents tests offset and gain. Four-terminal sensing helps keep high-current connection drops out of the sensed electric potential difference; an amplifier input common-mode range extending to the required near-return potentials is still necessary. Neither a near-zero common-mode voltage nor a successful gain check proves that the return-path insertion leaves the load undisturbed.

High-side current sensing measures an electric current with a sensor between the supply and the load, rather than between the load and its return reference as in low-side current sensing. With a shunt resistor, the useful signal is the difference between two input potentials that may both lie far above the amplifier's local reference. The amplifier input common-mode range therefore matters independently of the differential signal size.^[ref]

For an illustrative12volt supply, a50milliohm shunt resistor carrying2amperes developsThe sense terminals are at12.0 and11.9volts relative to the supply return, so their common-mode voltage is11.95volts. An ideal differential amplifier of gain20 would convert the100millivolt difference to2volts. A3.3volt output or digitizer range does not by itself establish that the amplifier inputs can accept11.95volts: that requires a suitable input stage and operating specifications.

The LTC6115 demonstrates an actual high-side arrangement: an external shunt resistor generates a differential electric potential difference, and external resistors set its conversion to an output signal. Its separate current-sense and voltage-sense supply conditions must not be conflated.^[ref]

Keeping the load return connected directly to the reference avoids the reference shift introduced by a return-path shunt resistor. The supply-side drop still reduces the available load electric potential difference. Separate sense connections implement four-terminal sensing; measuring through shared high-current tracks instead adds their drops to the inferred electric current.^[ref]

A CSS selector describes which elements a styling rule matches. It can constrain an element's type, HTML attributes, structural relationships or state. The declarations in a rule then apply to matching elements, subject to the CSS cascade; matching and choosing a winning declaration are separate operations.^[ref]

For example, p.warning matches a paragraph whose class list contains warning. Writing p .warning instead uses a descendant CSS combinator: it matches a classed element inside a paragraph, rather than requiring the paragraph itself to carry that class. The space is therefore meaningful syntax.

A child CSS combinator changes the relationship again. article > p.warning matches warning paragraphs directly inside an article, while article p.warning also permits intervening elements. A comma-separated selector list can describe alternatives, and a CSS pseudo-class such as :hover can test an element's state.^[ref]

A successful match says nothing by itself about whether one declaration defeats another. If both p.warning and #notice match an element, CSS specificity and earlier cascade priorities help choose the result. A CSS selector should also be distinguished from a CSS pseudo-element, which can address an abstract part or generated box rather than simply selecting another existing HTML element.

A CSS declaration associates a CSS property with a CSS property value, optionally marked important. In source syntax, a colon separates the name from the value, and semicolons separate declarations in a list. For example, color: red declares a foreground color; the surrounding CSS selector determines which elements the rule addresses.^[ref]

The rule p { color: red; width: 20px; } contains two CSS declarations. The braces enclose the block of CSS declarations. !important in color: red !important sets the declaration's priority flag; it is not part of the color value used to paint the text.

Parsing a declaration is only one stage of validation. width: blue has the superficial name-colon-value form, but blue is not a valid width value, so it does not supply a usable width declaration. An unrecognized property name is likewise not a way to create an arbitrary new built-in styling property. A preceding valid declaration can remain effective when a later invalid one is discarded.^[ref]

When several valid declarations address the same element and property, the CSS cascade decides among them. For ordinary declarations with equal prior cascade priorities and equal CSS specificity, a later declaration wins. The declaration expresses a candidate value; its presence in a file alone does not prove that the candidate becomes the element's final presentation.

The CSS cascade selects a winning declaration for each property on each element from the declarations that apply. Its ordering includes origin and importance, CSS cascade layers, CSS specificity and source order. Later comparisons settle ties left by earlier priorities; a rule's position at the end of a file is therefore only one part of the decision.^[ref]

Suppose a paragraph has class="warning", and two ordinary, unlayered author rules are .warning { color: red; } followed by p { color: blue; }. Both match, but the class selector has greater CSS specificity, so red wins despite the blue rule's later position. If the second rule is p { color: blue !important; }, its importance instead makes blue win over the normal red declaration. These examples hold other styling inputs fixed.

Origins represent different participants, including the browser's default rules, the user and the page author. For example, important user declarations outrank important author declarations, allowing user styling to take priority in that part of the system. Layer order is also a separate input; adding selectors with larger specificity is not a substitute for understanding that earlier comparison.^[ref]

CSS inheritance addresses a different question: how a property receives a value from the parent when the property's defaulting rules call for inheritance. A parent being red does not create a competing selector match on every descendant. Keeping applicability, cascade selection and inheritance distinct explains why an element can inherit a color even though no rule explicitly selects that element.

A CSS property is a defined parameter of presentation or layout, such as color, width or margin-left. Its definition specifies allowed values, an initial value, whether it inherits, and how values are computed. A CSS declaration proposes a value for a property on the elements matched by its rule.^[ref]

For example, width: 50% names the width property and supplies a percentage value. If that percentage resolves against a containing width of 400 CSS pixels, the resulting width is 200 CSS pixels in the simple case. The same declaration in a 600-pixel containing width can yield 300 pixels. A property name therefore identifies a parameter, while its eventual layout value can depend on context.

Different properties have different value grammars and defaulting behavior. A color word can be valid for color but invalid for width. Foreground color normally inherits, while width does not inherit by default. The absence of a width declaration is therefore different from automatically copying the parent's width.^[ref]

A property also differs from an HTML attribute with similar wording. Attribute interpretation is part of the element's document semantics; a CSS property participates in the styling value process, including the CSS cascade. Keeping the property definition, individual declarations and the resulting CSS used value separate makes styling behavior much easier to explain.

The CSS box model describes the content, padding, border and margin regions used to lay out generated boxes. These define a CSS content box, CSS padding box, CSS border box and CSS margin box respectively. A box's declared width must be interpreted together with the applicable sizing rules.^[ref]

For a simple horizontal box with content width $w$, left/right padding $p_l,p_r$, border widths $b_l,b_r$ and margins $m_l,m_r$, the total margin-box width isWith $w=100$, padding ten on each side, borders two on each side and margins ten on each side, the total is 144 CSS pixels. Its border box is 124 pixels wide.

CSS box-sizing changes which area a width declaration sizes. With the same padding and borders but box-sizing: border-box; width: 100px, the border box is 100 pixels and the content width is 76 pixels in this example. Margins are still outside that declared border-box size.^[ref]

The example assumes ordinary nonnegative fixed horizontal values. Vertical margins can participate in CSS margin collapsing, and an inline element split across lines can generate several fragments. The box model supplies the regions; the formatting context determines how particular boxes are generated and positioned.

CSS absolute positioning positions a generated box with respect to its CSS containing block, removing it from the ordinary flow that places its siblings. The declaration position: absolute selects this positioning scheme; offsets and size rules then determine its geometry. Its siblings do not reserve the space that it would otherwise have occupied.^[ref]

A simple example uses a positioned block ancestor with content width $300$ CSS pixels, twenty-pixel padding on both sides and content-box sizing. In the ordinary CSS2.2 case, this ancestor's padding edges establish a $340$-pixel-wide CSS containing block for an absolutely positioned descendant, provided no nearer qualifying ancestor intervenes.^[ref]

Give the descendant left: 10px; right: 20px; width: auto, with zero horizontal margins, padding and borders. The horizontal constraint becomesso its used content width is $310$ pixels. Alternatively, width: 50%; left: 10px; right: auto gives a width of $170$ pixels under the same assumptions. Offsets and percentages therefore refer to the selected containing geometry, not automatically to the ancestor's content width.^[ref]

Absolute positioning does not remove the DOM element from the DOM tree; it changes layout participation. It can allow boxes to overlap, but does not by itself specify clipping, permanent attachment to a screen position or every painting-order relationship. Use CSS overflow and the applicable positioning rules when diagnosing those separate effects.

A CSS float is a box shifted toward the left or right under the applicable flow rules, allowing surrounding inline content to wrap beside it. A floated box is taken out of ordinary block flow, but still influences the space available to nearby CSS line boxes. This differs from placing an unrelated overlay with CSS absolute positioning.^[ref]

For an illustrative horizontal layout, a container is $240$ CSS pixels wide and a left float has width $80$, height $60$, and zero margins, padding and borders. Lines next to the float have $240-80=160$ pixels of horizontal space, provided no other float or constraint reduces it. Below the float's bottom, a line can again use the full $240$ pixels. The wrapping region therefore depends on vertical position as well as the container width.

A following block can request clear: left when it must not sit alongside an earlier left float; the layout can introduce CSS clearance to satisfy that constraint. This changes placement rather than deleting or resizing the float.^[ref]

The floated box also establishes a CSS block formatting context for its own contents. Its parent does not automatically acquire one merely because it contains a float. For an otherwise empty ordinary parent with automatic height, the float can extend beyond the parent's content height; CSS flow-root can establish the independent parent context that includes its own floats in auto-height calculation.

Use floats when interaction with surrounding flow is intended. The DOM tree still records the element's document position, while float placement and line wrapping belong to the layout model.

A CSS writing mode describes the flow and orientation conventions used to lay out text and boxes. Its components include CSS inline direction, CSS block flow direction and CSS glyph orientation. The properties direction, writing-mode and text-orientation have separate roles in establishing those conventions.^[ref]

The writing-mode property specifies horizontal or vertical flow and the block-flow direction. With horizontal-tb, successive blocks progress downward. With vertical-rl, inline layout is vertical and successive blocks progress from right to left. The suffix rl therefore concerns block progression; it does not by itself specify the order of characters along every line.^[ref]

For a concrete box example, set inline-size: 120px; block-size: 60px; direction: ltr;. Assume a simple unconstrained non-replaced box, without padding, borders, transforms or competing size limits. Under writing-mode: horizontal-tb, its physical width is $120$ CSS pixels and height $60$. Under writing-mode: vertical-rl, its physical width is $60$ pixels and height $120$. The logical inline dimension follows the text-flow axis rather than always naming physical width.^[ref]

Changing direction to rtl in the horizontal example places inline-start on the right, while block-start remains at the top. In the vertical example with direction: ltr, inline-start is at the top and block-start is on the right. These mappings help explain why a CSS scroll origin need not be a physical top-left corner.^[ref]

CSS glyph orientation then controls how individual glyphs are oriented within vertical text. This is different from rotating an already laid-out box: a writing-mode change also affects line arrangement, block progression and the mapping of logical dimensions. Keeping those effects separate makes vertical layouts and direction-dependent interfaces easier to reason about.

A CSS transform changes the coordinate mapping used to render a transformable element. Translation, scaling and rotation are examples of CSS transform functions. Their composition maps local points into the parent coordinate system; the CSS transform origin specifies the point around which the transformation is constructed.^[ref]

For an own two-dimensional example, use an ordinary CSS box with transform-box: border-box; transform-origin: 0 0;, no ancestor transforms, and local coordinates relative to that top-left origin. This fixes the CSS transform reference box and origin explicitly. Ignore the box's placement offset to isolate the transform itself.

Using homogeneous column vectors, letThe list transform: translate(10px, 0) scale(2); gives the product $TS$. Applied to point $(3,4,1{)}^{\mathsf{T}}$, the scale acts first:Reversing the list to scale(2) translate(10px, 0) gives $ST$ and the result $(26,8,1{)}^{\mathsf{T}}$. The translation is scaled in the reversed composition. Matrix multiplication explains the order dependence.^[ref]

The zero origin is part of the example, not an irrelevant decoration. A different origin adds translations around the listed operations and can change the mapped point. The simple matrix computation also fixes its column-vector convention instead of relying on an ambiguous phrase such as applying functions in order.

For boxes governed by the CSS box model, a transform changes rendering without rearranging the surrounding normal-flow content. It can nevertheless extend CSS overflow, and transformed geometry affects client rectangles. The absence of normal-flow re-layout is therefore not a claim that every geometrical or scrolling quantity stays fixed.^[ref]

The same transformed bounds matter when constructing a CSS scroll snap area. A rendered border can be rotated while its axis-aligned bounding box is used for alignment geometry. Separating layout boxes, coordinate mappings and derived bounds makes these effects easier to calculate.

Lattice-based cryptography constructs security mechanisms from computational problems associated with Euclidean lattices and related noisy linear equations. A lattice is easy to describe by a basis, while finding particular short vectors or recovering hidden information from noisy equations can be difficult in suitably chosen dimensions and parameter ranges. Different constructions rely on different problems and reductions.

For the schematic learning with errors relation $b=As+e(\mathrm{mod}q)$, $A$ and $b$ are public, while the secret vector $s$ is masked by a small error vector $e$. With no error, ordinary modular linear algebra may recover $s$ efficiently when the system has suitable rank. The noise changes the problem. Real security depends on error distribution, dimension, modulus, available samples and attack model, rather than merely making the displayed equation look complicated. ML-KEM and ML-DSA illustrate encapsulation and signature applications; they use structured module arithmetic to obtain practical sizes and computation costs.