text:
# ngraph package¶

ngraph module namespace, exposing factory functions for all ops and other classes.

## ngraph.exceptions module¶

ngraph exceptions hierarchy. All exceptions are descendants of NgraphError.

exception ngraph.exceptions.NgraphError[source]

Bases: Exception

Base class for Ngraph exceptions.

exception ngraph.exceptions.NgraphTypeError[source]

Bases: ngraph.exceptions.NgraphError, TypeError

Type mismatch error.

exception ngraph.exceptions.UserInputError[source]

User provided unexpected input.

## ngraph.ops module¶

Factory functions for all ngraph ops.

ngraph.ops.absolute(node, name=None)[source]

Return node which applies f(x) = abs(x) to the input node element-wise.

Parameters: node – One of: input node, array or scalar. name – Optional new name for output node. New node with Abs operation applied on it.
ngraph.ops.acos(node, name=None)[source]

Apply inverse cosine function on the input node element-wise.

Parameters: node – One of: input node, array or scalar. name – Optional new name for output node. New node with arccos operation applied on it.
ngraph.ops.add(left_node, right_node, name=None)[source]

Return node which applies f(x) = A+B to the input nodes element-wise.

ngraph.ops.argmax(data, axis=0)[source]

Return a node which performs ArgMax index reduction operation.

Parameters: data – Input data. axis – Reduction Axis. The new node which performs ArgMax
ngraph.ops.argmin(data, axis=0)[source]

Return a node which performs ArgMin index reduction operation.

Parameters: data – Input data. axis – Reduction Axis. The new node which performs ArgMin
ngraph.ops.asin(node, name=None)[source]

Apply inverse sine function on the input node element-wise.

Parameters: node – One of: input node, array or scalar. name – Optional new name for output node. New node with arcsin operation applied on it.
ngraph.ops.atan(node, name=None)[source]

Apply inverse tangent function on the input node element-wise.

Parameters: node – One of: input node, array or scalar. name – Optional new name for output node. New node with arctan operation applied on it.
ngraph.ops.avg_pool(data_batch, window_shape, window_strides=None, padding_below=None, padding_above=None, include_padding=False, name=None)[source]

Return average pooling node.

Parameters: data_batch – The input node providing data. window_shape – The pooling window shape. window_strides – The window movement strides. padding_below – The input data optional padding below filled with zeros. padding_above – The input data optional padding below filled with zeros. include_padding – Whether or not to include zero padding in average computations. name – Optional name for the new output node. New node with AvgPool operation applied on its data.
ngraph.ops.batch_norm(eps, gamma, beta, data, mean=None, variance=None, name=None)[source]

Return batch normalization node.

ngraph.ops.broadcast(node, new_shape, broadcast_axes, name=None)[source]

Create a node which broadcasts the input node’s values along specified axes to a desired shape.

Parameters: node – The node with input tensor data. new_shape – The new shape we want to broadcast tensor to. broadcast_axes – The axis positions (0-based) in the result that are being broadcast. name – Optional new name for output node. New node with broadcast shape.
ngraph.ops.broadcast_to(node, new_shape, axis=None, name=None)[source]

Create a node which broadcasts the input node’s values to a desired shape.

The optional axis parameter specifies the starting axis position (0-based) in the output shape from which the current shape of the tensor matches the desired new shape.

e.g. current_shape: [4, 5], new_shape: [2, 3, 4, 5, 6], axis: 2

By using the axis parameter you can control which output axis to broadcast along.

Example:

>>> input_node = ng.constant([1, 2, 3])
>>> current_shape = [3]
>>> new_shape = [3, 3]
array([[1, 2, 3],
[1, 2, 3],
[1, 2, 3]])

>>> ng.broadcast_to(input_node, new_shape, axis=0)
array([[1, 1, 1],
[2, 2, 2],
[3, 3, 3]])

If the axis parameter is not specified, broadcast_to will attempt to match shapes, assuming the current shape matches the rightmost positions of the desired new shape. This behaviour is similar to NumPy’s broadcasting.

i.e. default axis = len(new_shape) - len(current_shape)

Parameters: node – The node with input tensor data. new_shape – The new shape we want to broadcast tensor to. axis – The axis along which we perform broadcasting. name – Optional new name for output node. New node with broadcast shape.
ngraph.ops.ceiling(node, name=None)[source]

Return node which applies ceiling to the input node element-wise.

Parameters: node – The node providing data to ceiling operation. name – Optional name for output node. The node performing element-wise ceiling.
ngraph.ops.clamp(data, min_value, max_value, name=None)[source]

Perform clamp element-wise on data from input node.

Performs a clipping operation on an input value between a pair of boundary values.

For each element in data, if the element’s value is lower than min_value, it will be replaced with min_value. If the value is higher than max_value, it will be replaced by max_value. Intermediate values of data are returned without change.

Clamp uses the following logic:

if data < min_value:
data=min_value
elif data > max_value:
data=max_value

Parameters: data – Input tensor. One of: input node, array or scalar. min_value – The lower bound of the range. Scalar value. max_value – The upper bound of the range. Scalar value. name – Optional output node name. The new node performing a clamp operation on its input data element-wise.
ngraph.ops.concat(nodes, axis, name=None)[source]

Concatenate input nodes into single new node along specified axis.

Parameters: nodes – The nodes we want concatenate into single new node. axis – The axis along which we want to concatenate input nodes. name – The optional new name for output node. Return new node that is a concatenation of input nodes.
ngraph.ops.constant(value, dtype=None, name=None)[source]

Create a Constant node from provided value.

Parameters: value – One of: array of values or scalar to initialize node with. dtype – The data type of provided data. name – Optional name for output node. The Constant node initialized with provided data.
ngraph.ops.convert(node, new_type, name=None)[source]

Return node which casts input node values to specified type.

ngraph.ops.convolution(data_batch, filter_weights, filter_strides=None, filter_dilation_strides=None, padding_below=None, padding_above=None, data_dilation_strides=None, name=None)[source]

Return node performing batched convolution operation.

Parameters: data_batch – The node providing data batch tensor. filter_weights – The node providing filters tensor. filter_strides – The kernel window movement strides. filter_dilation_strides – The filters dilation strides. padding_below – The number of zero padding elements to add on each axis below 0 coordinate. padding_above – The number of zero padding elements to add on each axis above max coordinate. data_dilation_strides – The data batch dilation strides. name – The optional new name for output node. New node performing batched convolution operation.
ngraph.ops.convolution_backprop_data(data_batch_shape, filters, output_delta, window_movement_strides_forward=None, window_dilation_strides_forward=None, padding_below_forward=None, padding_above_forward=None, data_dilation_strides_forward=None, name=None)[source]

Return node performing a batched-convolution data batch-backprop operation.

Parameters: data_batch_shape – The shape of the data batch from forward-prop. filters – The node producing the filters from forward-prop. output_delta – The node producing output delta. window_movement_strides_forward – The window movement strides from forward-prop. window_dilation_strides_forward – The window dilation strides from forward-prop. padding_below_forward – The padding-below sizes from forward-prop. padding_above_forward – The padding-above sizes from forward-prop. data_dilation_strides_forward – The data dilation strides from forward-prop.
ngraph.ops.cos(node, name=None)[source]

Apply cosine function on the input node element-wise.

Parameters: node – One of: input node, array or scalar. name – Optional new name for output node. New node with cos operation applied on it.
ngraph.ops.cosh(node, name=None)[source]

Apply hyperbolic cosine function on the input node element-wise.

Parameters: node – One of: input node, array or scalar. name – Optional new name for output node. New node with cosh operation applied on it.
ngraph.ops.depth_to_space(node, mode, block_size, name=None)[source]

Rearranges input tensor from depth into blocks of spatial data.

Values from the height and width dimensions are moved to the depth dimension.

Input tensor has shape [N,C,H,W], where N is the batch axis, C is the channel or depth, H is the height and W is the width.

Output node produces a tensor with shape:

[N, C * block_size * block_size, H / block_size, W / block_size]

Parameters: node – The node with input tensor data. mode – Specifies how the input depth dimension is split to block coordinates blocks_first: The input is divided to [block_size, …, block_size, new_depth] depth_first: The input is divided to [new_depth, block_size, …, block_size] block_size – The size of the spatial block of values describing how the tensor’s data is to be rearranged. name – Optional output node name. The new node performing an DepthToSpace operation on its input tensor.
ngraph.ops.dequantize(data, scale, zero_point, element_type, axes, name=None)[source]

Perform dequantize operation on data from input node.

Computes dequantize on the input tensor:

$output = (input - zero\_point) * scale$
Parameters: data – The node with data tensor. scale – Scale used for mapping. zero_point – Zero point used for mapping. element_type – Output element type. name – Optional output node name. The new node performing a dequantize operation on input tensor.
ngraph.ops.divide(left_node, right_node, name=None)[source]

Return node which applies f(x) = A/B to the input nodes element-wise.

Parameters: left_node – The node providing dividend data. right_node – The node providing divisor data. name – Optional name for output node. The node performing element-wise division.
ngraph.ops.dot(left_node, right_node, reduction_axes_count=None, name=None)[source]

Return node which performs generalized dot product of two input nodes.

This operation is capable of performing scalar-tensor, matrix-vector product and matrix multiplication.

Parameters: left_node – The node providing left hand side data. right_node – The node providing right hand side data. reduction_axes_count – The number of axes to reduce during dot-product. name – The optional name for output node. The new node performing dot-product on input two nodes.
ngraph.ops.elu(data, alpha, name=None)[source]

Perform Exponential Linear Unit operation element-wise on data from input node.

Computes exponential linear: alpha * (exp(data) - 1) if < 0, data otherwise.

For more information refer to: Fast and Accurate Deep Network Learning by Exponential Linear Units (ELUs)

Parameters: data – Input tensor. One of: input node, array or scalar. alpha – Scalar multiplier for negative values. name – Optional output node name. The new node performing an ELU operation on its input data element-wise.
ngraph.ops.equal(left_node, right_node, name=None)[source]

Return node which checks if input nodes are equal element-wise.

Parameters: left_node – The first input node for equal operation. right_node – The second input node for equal operation. name – The optional name for output new node. The node performing element-wise equality check.
ngraph.ops.exp(node, name=None)[source]

Return node which applies exp to the input node element-wise.

Parameters: node – The node providing data for operation. name – The optional name for new output node. The new node performing natural exponential operation.
ngraph.ops.fake_quantize(data, input_low, input_high, output_low, output_high, levels, name=None)[source]

Perform an element-wise linear quantization on input data.

Input floating point values are quantized into a discrete set of floating point values.

Fake quantize uses the following logic:

$output = \dfrac{round( \dfrac{data - input\_low}{(input\_high - input\_low)\cdot (levels-1)})} {(levels-1)\cdot (output\_high - output\_low)} + output\_low$
Parameters: data – The node with data tensor. input_low – The node with the minimum for input values. input_high – The node with the maximum for input values. output_low – The node with the minimum quantized value. output_high – The node with the maximum quantized value. levels – The number of quantization levels. Integer value. New node with quantized value.
ngraph.ops.floor(node, name=None)[source]

Return node which applies floor to the input node element-wise.

Parameters: node – The input node providing data. name – The optional name for new output node. The node performing element-wise floor operation.
ngraph.ops.gelu(node, name=None)[source]

Perform Gaussian Error Linear Unit operation element-wise on data from input node.

Computes GELU function:

$f(x) = 0.5\cdot x\cdot(1 + erf( \dfrac{x}{\sqrt{2}})$

Parameters: node – Input tensor. One of: input node, array or scalar. name – Optional output node name. The new node performing a GELU operation on its input data element-wise.
ngraph.ops.gemm(A, B, C, alpha, beta, transA, transB, name=None)[source]

Perform General matrix-matrix multiplication on input tensors A, B and C.

Computes:

$Y = alpha\cdot A'\cdot B' + beta\cdot C$

A' is the transpose of matrix A with shape (M, K), if transA is True, otherwise A with shape (K, N).

B' is the transpose of matrix B with shape (K, N), if transB is True, otherwise B with shape (N, K).

C: Matrix broadcastable to shape (M, N).

Y: Matrix with shape (M, N).

Parameters: A – The node with input tensor A. B – The node with input tensor B. C – The node with input tensor C. alpha – Scalar multiplier for the product of input tensors A * B. beta – Scalar multiplier for input tensor C. transA – Whether A should be transposed. Boolean value. transB – Whether B should be transposed. Boolean value. name – Optional name for the output node. Return node with tensor of shape (M, N).
ngraph.ops.get_output_element(data, index)[source]

Return the n-th element of the input tuple.

ngraph.ops.greater(left_node, right_node, name=None)[source]

Return node which checks if left input node is greater than the right node element-wise.

Parameters: left_node – The first input node providing data. right_node – The second input node providing data. name – The optional new name for output node. The node performing element-wise check whether left_node is greater than right_node.
ngraph.ops.greater_eq(left_node, right_node, name=None)[source]

Return node which checks if left node is greater or equal to the right node element-wise.

Parameters: left_node – The first input node providing data. right_node – The second input node providing data. name – The optional new name for output node. The node performing element-wise check whether left_node is greater than or equal right_node.
ngraph.ops.grn(data, bias, name=None)[source]

Perform Global Response Normalization with L2 norm (across channels only).

Computes GRN operation on channels for input tensor:

$output_i = \dfrac{input_i}{\sqrt{\sum_{i}^{C} input_i}}$
Parameters: data – The node with data tensor. bias – The bias added to the variance. Scalar value. name – Optional output node name. The new node performing a GRN operation on tensor’s channels.
ngraph.ops.group_convolution(data_batch, filters, window_movement_strides, window_dilation_strides, padding_below, padding_above, data_dilation_strides, groups, pad_type='EXPLICIT', name=None)[source]

Perform Group Convolution operation on data from input node.

ngraph.ops.hard_sigmoid(data, alpha, beta, name=None)[source]

Perform Hard Sigmoid operation element-wise on data from input node.

Hard Sigmoid uses the following logic:

y = max(0, min(1, alpha * data + beta))

Parameters: data – The node with data tensor. alpha – Alpha parameter. Scalar value. beta – Beta parameter. Scalar value. name – Optional output node name. The new node performing a Hard Sigmoid element-wise on input tensor.
ngraph.ops.less(left_node, right_node, name=None)[source]

Return node which checks if left input node is less than the right node element-wise.

Parameters: left_node – The first input node providing data. right_node – The second input node providing data. name – The optional new name for output node. The node performing element-wise check whether left_node is less than the right_node.
ngraph.ops.less_eq(left_node, right_node, name=None)[source]

Return node which checks if left input node is less or equal the right node element-wise.

Parameters: left_node – The first input node providing data. right_node – The second input node providing data. name – The optional new name for output node. The node performing element-wise check whether left_node is less than or equal the right_node.
ngraph.ops.log(node, name=None)[source]

Return node which applies natural logarithm to the input node element-wise.

Parameters: node – The input node providing data for operation. name – The optional new name for output node. The new node performing log operation element-wise.
ngraph.ops.logical_and(left_node, right_node, name=None)[source]

Return node which perform logical and operation on input nodes element-wise.

Parameters: left_node – The first input node providing data. right_node – The second input node providing data. name – The optional new name for output node. The node performing logical and operation on input nodes corresponding elements.
ngraph.ops.logical_not(node, name=None)[source]

Return node which applies logical negation to the input node elementwise.

ngraph.ops.logical_or(left_node, right_node, name=None)[source]

Return node which performs logical or operation on input nodes element-wise.

Parameters: left_node – The first input node providing data. right_node – The second input node providing data. name – The optional new name for output node. The node performing logical or operation on input nodes corresponding elements.
ngraph.ops.lrn(data, alpha=1, beta=0.5, bias=1, size=5, name=None)[source]

Return a node which performs element-wise Local Response Normalization (LRN) operation.

Parameters: data – Input data. alpha – A scale factor (usually positive). beta – An exponent. bias – An offset (usually positive) to avoid dividing by 0. size – Width of the 1-D normalization window. name – An optional name of the output node. The new node which performs LRN.
ngraph.ops.max(node, reduction_axes=None, name=None)[source]

Max-reduction operation on input tensor, eliminating the specified reduction axes.

Parameters: node – The tensor we want to max-reduce. reduction_axes – The axes to eliminate through max operation. name – Optional name for output node.
ngraph.ops.max_pool(x, window_shape, strides=None, padding_above=None, padding_below=None, name=None)[source]

Return max pooling node.

ngraph.ops.maximum(left_node, right_node, name=None)[source]

Return node which applies the maximum operation to input nodes elementwise.

ngraph.ops.min(node, reduction_axes=None, name=None)[source]

Min-reduction operation on input tensor, eliminating the specified reduction axes.

Parameters: node – The tensor we want to min-reduce. reduction_axes – The axes to eliminate through min operation. name – Optional name for output node.
ngraph.ops.minimum(left_node, right_node, name=None)[source]

Return node which applies the minimum operation to input nodes elementwise.

ngraph.ops.multiply(left_node, right_node, name=None)[source]

Return node which applies f(x) = A*B to the input nodes elementwise.

ngraph.ops.mvn(data, axes, normalize_variance, eps, name=None)[source]

Perform Mean Variance Normalization operation on data from input node.

Computes MVN on the input tensor data (called X) using formula:

$Y = \dfrac{X-EX}{\sqrt{E(X-EX)^2}}$
Parameters: data – The node with data tensor. axes – A list of axes, along which to reduce. Array of integers. normalize_variance – Flag that denotes if mean values are shared across channels. Boolen value. eps – The number added to the variance to avoid division by zero when normalizing the value. Scalar value. name – Optional output node name. The new node performing a MVN operation on input tensor.
ngraph.ops.negative(node, name=None)[source]

Return node which applies f(x) = -x to the input node elementwise.

ngraph.ops.not_equal(left_node, right_node, name=None)[source]

Return node which checks if input nodes are unequal element-wise.

Parameters: left_node – The first input node for not-equal operation. right_node – The second input node for not-equal operation. name – The optional name for output new node. The node performing element-wise inequality check.
ngraph.ops.one_hot(node, shape, one_hot_axis, name=None)[source]

Create node performing one-hot encoding on input data.

Parameters: node – The input node providing data for operation. shape – The output node shape including the new one-hot axis. one_hot_axis – The index within the output shape of the new one-hot axis. name – The optional name for new output node. New node performing one-hot operation.
ngraph.ops.pad(data_batch, value, padding_below=None, padding_above=None, padding_in=None, name=None)[source]

Parameters: data_batch – The input node providing data. value – The node producing the scalar value to be inserted for padding. padding_below – The padding-below widths. padding_above – The padding-above widths. padding_in – The interior-padding widths. name – The optional new name for output node. Return node that represents a padding of input nodes data.
ngraph.ops.parameter(shape, dtype=<class 'numpy.float32'>, name=None)[source]

Return an ngraph Parameter object.

ngraph.ops.power(left_node, right_node, name=None)[source]

Return node which perform element-wise exponentiation operation.

Parameters: left_node – The node providing the base of operation. right_node – The node providing the exponent of operation. name – The optional name for the new output node. The new node performing element-wise exponentiation operation on input nodes.
ngraph.ops.prelu(data, slope, name=None)[source]

Perform Parametrized Relu operation element-wise on data from input node.

PRelu uses the following logic:

if data < 0:
data = data * slope
elif data >= 0:
data = data

Parameters: data – The node with data tensor. slope – The node with the multipliers for negative values. name – Optional output node name. The new node performing a PRelu operation on tensor’s channels.
ngraph.ops.prod(node, reduction_axes=None, name=None)[source]

Product-reduction operation on input tensor, eliminating the specified reduction axes.

Parameters: node – The tensor we want to product-reduce. reduction_axes – The axes to eliminate through product operation. name – Optional name for output node. The new node performing product-reduction operation.
ngraph.ops.quantize(data, scale, zero_point, new_type, axes, round_mode, name=None)[source]

Perform quantize operation on data from input node.

Computes quantize on the input tensor:

$output = ROUND((input / scale) + zero\_point)$
Parameters: data – The node with data tensor. scale – Scale used for mapping. zero_point – Zero point used for mapping. new_type – Output element type. round_mode – Number describes how to perform ROUND function. ROUND_NEAREST_TOWARD_INFINITY: Round to nearest integer. In case of two equidistant integers round away from zero e.g. 2.5 -> 3, -3.5 -> -4 ROUND_NEAREST_TOWARD_ZERO: Round to nearest integer. In case of two equidistant integers round toward zero e.g. 2.5 -> 2, -3.5 -> -3 ROUND_NEAREST_UPWARD: Round to nearest integer. In case of two equidistant integers round up e.g. 2.5 -> 2, -3.5 -> -3 ROUND_NEAREST_DOWNWARD: Round to nearest integer. In case of two equidistant integers round down e.g. 2.5 -> 2, -3.5 -> -4 ROUND_NEAREST_TOWARD_EVEN: Round to nearest integer. In case of two equidistant integers round down e.g. 2.5 -> 2, -3.5 -> -4 ROUND_TOWARD_INFINITY: Round to nearest integer away from zero. ROUND_TOWARD_ZERO: Round to nearest integer toward zero. ROUND_UP: Round to nearest integer toward infinity (ceiling). ROUND_DOWN: Round to nearest integer toward negative infinity (floor). name – Optional output node name. The new node performing a quantize operation on input tensor.
ngraph.ops.quantized_convolution(data, filters, window_movement_strides, window_dilation_strides, padding_below, padding_above, data_dilation_strides, input_scale, input_zero_point, filter_scale, filter_zero_point, output_scale, output_zero_point, output_type, input_axes, filter_axes, output_axes, name=None)[source]

Perform quantized convolution operation on data from input node.

Parameters: data – The node producing the input data batch tensor. filters – The node producing the filters tensor. window_movement_strides – The window movement strides. window_dilation_strides – he window dilation strides. padding_below – The padding-below sizes. padding_above – The padding-above sizes. data_dilation_strides – The data dilation strides. input_scale – Scale to transform the input. input_zero_point – Zero point used for mapping. filter_scale – Scale to transform the filters. filter_zero_point – Zero point used for mapping. output_scale – Scale to transform the output. output_zero_point – Zero point used for mapping. output_type – Output element type. input_axes – Input axes set for channel wise quantization. filter_axes – Filter axes set for channel wise quantization. output_type – Output axes set for channel wise quantization. name – Optional output node name. The new node performing a quantized convolution operation on input tensor.
ngraph.ops.quantized_dot(input0, input1, reduction_axes_count, input0_scale, input0_zero_point, input1_scale, input1_zero_point, output_scale, output_zero_point, output_type, input0_axes, input1_axes, output_axes, name=None)[source]

Perform quantized dot operation on data from input node.

Parameters: input0 – The node producing the input data batch tensor. input1 – The node producing the filters tensor. reduction_axes_count – Number of reduction axes. input0_scale – Scale to transform the input. input0_zero_point – Zero point used for mapping. input1_scale – Scale to transform the filters. input1_zero_point – Zero point used for mapping. output_scale – Scale to transform the output. output_zero_point – Zero point used for mapping. output_type – Output element type. input0_axes – Input0 axes set for channel wise quantization input1_axes – Input1 axes set for channel wise quantization output_axes – Output axes set for channel wise quantization name – Optional output node name. The new node performing a quantized dot operation on input tensor.
ngraph.ops.relu(node, name=None)[source]

Perform rectified linear unit operation on input node element-wise.

Parameters: node – One of: input node, array or scalar. name – The optional ouptut node name. The new node performing relu operation on its input element-wise.
ngraph.ops.replace_slice(dest_node, src_node, lower_bounds, upper_bounds, strides=None, name=None)[source]

Return a copy of dest_node with the specified slice overwritten by the src_node data.

Parameters: dest_node – The node providing data to be overwritten by the specified slice. src_node – The node providing data for overwriting. lower_bounds – The (inclusive) lower-bound coordinates for the replaced slice. upper_bounds – The (exclusive) upper-bound coordinates for the replaced slice. strides – The strides for the replaced slice. name – The optional name for the output new node. The new node with copy of dest_node with the specified slice overwritten by the src_node.
ngraph.ops.reshape(node, output_shape, input_order=None, name=None)[source]

Return reshaped node according to provided parameters.

Parameters: node – The tensor we want to reshape. input_order – The order in which to iterate over input axes of input tensor. output_shape – The new shape for input tensor.
ngraph.ops.reverse(node, reversed_axes, name=None)[source]

Perform axis-reverse operation.

Parameters: node – The input node on which operation will be carried out. reversed_axes – The list of indices of axes to be reversed. name – The optional name of the output node. The new node with reversed axes.
ngraph.ops.rnn_cell(X, H_t, W, R, B, hidden_size, activations, activation_alpha, activation_beta, clip, name=None)[source]

Perform RNNCell operation on tensor from input node.

It follows notation and equations defined as in ONNX standard: https://github.com/onnx/onnx/blob/master/docs/Operators.md#RNN

Note this class represents only single cell and not whole RNN layer.

Parameters: X – The input tensor with shape: [batch_size, input_size]. H_t – The hidden state tensor at current time step with shape: [batch_size, hidden_size]. W – The weight tensor with shape: [hidden_size, input_size]. R – The recurrence weight tensor with shape: [hidden_size, hidden_size]. B – The bias tensor for input gate with shape: [2*hidden_size]. hidden_size – The number of hidden units for recurrent cell. activations – The vector of activation functions used inside recurrent cell. activation_alpha – The vector of alpha parameters for activation functions in order respective to activation list. activation_beta – The vector of beta parameters for activation functions in order respective to activation list. clip – The value defining clipping range [-clip, clip] on input of activation functions. name – Optional output node name. The new node performing a RNNCell operation on tensor from input node.
ngraph.ops.scale_shift(data, scale, shift, name=None)[source]

Perform ScaleShift transformation on input node.

Computes ScaleShift:

$Y = scale\cdot data + shift$
Parameters: data – The node with data tensor. scale – The node with data tensor that scale input data. shift – The node with data tensor that shift input data. name – Optional output node name. The new node performing a ScaleShift operation on input tensor.
ngraph.ops.select(selection_node, input_node1, input_node2, name=None)[source]

Perform an element-wise selection operation on input tensors.

Parameters: selection_node – The node providing selection values of bool type. input_node1 – The node providing data to be selected if respective selection_node item value is True. input_node2 – The node providing data to be selected if respective selection_node item value is False. name – The optional new name for output node. The new node with values selected according to provided arguments.
ngraph.ops.shuffle_channels(data, axis, groups, name=None)[source]

Perform permutation on data in the channel dimension of the input tensor.

The operation is the equivalent with the following transformation of the input tensor data of shape [N, C, H, W]:

data_reshaped = reshape(data, [N, group, C / group, H * W])

data_trnasposed = transpose(data_reshaped, [0, 2, 1, 3])

output = reshape(data_trnasposed, [N, C, H, W])

For example:

Inputs: tensor of shape [1, 6, 2, 2]

data = [[[[ 0.,  1.], [ 2.,  3.]],
[[ 4.,  5.], [ 6.,  7.]],
[[ 8.,  9.], [10., 11.]],
[[12., 13.], [14., 15.]],
[[16., 17.], [18., 19.]],
[[20., 21.], [22., 23.]]]]

axis = 1
groups = 3

Output: tensor of shape [1, 6, 2, 2]

output = [[[[ 0.,  1.], [ 2.,  3.]],
[[ 8.,  9.], [10., 11.]],
[[16., 17.], [18., 19.]],
[[ 4.,  5.], [ 6.,  7.]],
[[12., 13.], [14., 15.]],
[[20., 21.], [22., 23.]]]]

Parameters: data – The node with input tensor. axis – Channel dimension index in the data tensor. A negative value means that the index should be calculated from the back of the input data shape.
:param group:The channel dimension specified by the axis parameter
should be split into this number of groups.
Parameters: name – Optional output node name. The new node performing a permutation on data in the channel dimension of the input tensor.
ngraph.ops.sign(node, name=None)[source]

Perform element-wise sign operation.

Parameters: node – One of: input node, array or scalar. name – The optional new name for ouptut node. The node with mapped elements of the input tensor to -1 (if it is negative), 0 (if it is zero), or 1 (if it is positive).
ngraph.ops.sin(node, name=None)[source]

Apply sine function on the input node element-wise.

Parameters: node – One of: input node, array or scalar. name – Optional new name for output node. New node with sin operation applied on it.
ngraph.ops.sinh(node, name=None)[source]

Apply hyperbolic sine function on the input node element-wise.

Parameters: node – One of: input node, array or scalar. name – Optional new name for output node. New node with sin operation applied on it.
ngraph.ops.slice(node, lower_bounds, upper_bounds, strides=None, name=None)[source]

Take a slice of an input tensor, (sub-tensor) that resides within a bounding box.

Optionally this function may be provided with stride along each axis.

Parameters: node – The tensor we want to slice. lower_bounds – The (inclusive) lower-bound coordinates for the tensor slice. upper_bounds – The (exclusive) upper-bound coordinates for the tensor slice. strides – The strides for the tensor slice. name – Optional name for the output node. Return node that represents a slice of input nodes data.
ngraph.ops.softmax(node, axes, name=None)[source]

Apply softmax operation on each element of input tensor.

Parameters: node – The tensor providing input data. axes – The list of axes indices which are used to calculate divider of the softmax function. name – The optional new name for output node. The new node with softmax operation applied on each element.
ngraph.ops.space_to_depth(data, mode, block_size, name=None)[source]

Perform SpaceToDepth operation on the input tensor.

SpaceToDepth rearranges blocks of spatial data into depth. The operator returns a copy of the input tensor where values from the height and width dimensions are moved to the depth dimension.

Parameters: data – The node with data tensor. mode – Specifies how the output depth dimension is gathered from block coordinates. blocks_first: The output depth is gathered from [block_size, …, block_size, C] depth_first: The output depth is gathered from [C, block_size, …, block_size] block_size – The size of the block of values to be moved. Scalar value. name – Optional output node name. The new node performing a SpaceToDepth operation on input tensor.
ngraph.ops.sqrt(node, name=None)[source]

Return node which applies square root to the input node element-wise.

Parameters: node – One of: input node, array or scalar. name – Optional new name for output node. The new node with sqrt operation applied element-wise.
ngraph.ops.squared_difference(x1, x2, name=None)[source]

Perform an element-wise squared difference between two tensors.

$y[i] = (x_1[i] - x_2[i])^2$
Parameters: x1 – The node with first input tensor. x2 – The node with second input tensor. name – Optional new name for output node. The new node performing a squared difference between two tensors.
ngraph.ops.squeeze(data, axes, name=None)[source]

Perform squeeze operation on input tensor.

Remove single-dimensional entries from the shape of a tensor. Takes a parameter axes with a list of axes to squeeze. If axes is not provided, all the single dimensions will be removed from the shape. If an axis is selected with shape entry not equal to one, an error is raised.

For example:

Inputs: tensor with shape [1, 2, 1, 3, 1, 1], axes=[2, 4]

Result: tensor with shape [1, 2, 3, 1]

Parameters: data – The node with data tensor. axes – List of non-negative integers, indicate the dimensions to squeeze. One of: input node or array. name – Optional new name for output node. The new node performing a squeeze operation on input tensor.
ngraph.ops.subtract(left_node, right_node, name=None)[source]

Return node which applies f(x) = A-B to the input nodes element-wise.

Parameters: left_node – The node providing data for left hand side of operator. right_node – The node providing data for right hand side of operator. name – The optional name for output node. The new output node performing subtraction operation on both tensors element-wise.
ngraph.ops.sum(node, reduction_axes=None, name=None)[source]

Perform element-wise sums of the input tensor, eliminating the specified reduction axes.

Parameters: node – The node providing data for operation. reduction_axes – The axes to eliminate through summation. name – The optional new name for ouptut node. The new node performing summation along reduction_axes element-wise.
ngraph.ops.tan(node, name=None)[source]

Apply tangent function on the input node element-wise.

Parameters: node – One of: input node, array or scalar. name – Optional new name for output node. New node with tan operation applied on it.
ngraph.ops.tanh(node, name=None)[source]

Return node which applies hyperbolic tangent to the input node element-wise.

Parameters: node – One of: input node, array or scalar. name – Optional new name for output node. New node with tanh operation applied on it.
ngraph.ops.topk(data, k, kaxis=-1, cmax=True)[source]

Return a node which performs TopK.

Parameters: data – Input data. kaxis – TopK Axis. k – cmax – Compute TopK largest (True) or smallest (False) The new node which performs TopK (both indices and values)
ngraph.ops.unsqueeze(data, axes, name=None)[source]

Perform unsqueeze operation on input tensor.

Insert single-dimensional entries to the shape of a tensor. Takes one required argument axes, a list of dimensions that will be inserted. Dimension indices in axes are as seen in the output tensor.

For example: Inputs: tensor with shape [3, 4, 5], axes=[0, 4]
Result: tensor with shape [1, 3, 4, 5, 1]
Parameters: data – The node with data tensor. axes – List of non-negative integers, indicate the dimensions to be inserted. One of: input node or array. The new node performing an unsqueeze operation on input tensor.

## ngraph.runtime module¶

Provide a layer of abstraction for the ngraph++ runtime environment.

class ngraph.runtime.Computation(runtime, ng_function)[source]

Bases: object

ngraph callable computation object.

serialize(indent=0)[source]

Serialize function (compute graph) to a JSON string.

Parameters: indent – set indent of serialized output serialized model
class ngraph.runtime.Runtime(backend_name)[source]

Bases: object

Represents the ngraph++ runtime environment.

computation(node_or_function, *inputs)[source]

Return a callable Computation object.

ngraph.runtime.runtime(backend_name='CPU')[source]

Create a Runtime object (helper factory).

Use signature to parameterize runtime as needed.


text:
# Is there a natural distance between skew hermitian matrices?

Working in machine learning, I try to find a way to compare time series, which can be considered as semi-continuous matrices belonging to $\mathbb R^{n \times \mathbb R}$ (a column corresponds to n-dimensional the value of the time series at a given time). A first step would be to consider the Gramian of the time series $u \in \mathbb R^{n \times \mathbb R}$: $M(u) = u.u' \in \mathbb R^{n \times n}$ (where $'$ is the transpose operator and $.$ is the integration along time). The good point is that $M(u)$ is semi-definite positive and that there is a natural Riemannian distance on the space of positive definite matrices (see the first pages of this paper for a short intro): $$d(M,N) = \|Log(M^{-1}.N) \|_{\mbox{Froebenius}}$$ This is an idea to measure the similarity between the two time series.

For some (convoluted) reason, I am now interested in the matrices of the form $P(u) = u.A.u' \in \mathbb R^{n \times n}$, where $A$ can be seen as a skew-symmetric matrix of $\mathbb R^{\mathbb R \times \mathbb R}$. So I have two questions:

1. Is there a natural distance on the set of skew symmetric (or skew hermitian) matrices? I guess the answer is "not in such a general framework". Thus my second question is:
2. In the more particular case presented above: $P(u)$ is a Gram-like skew symmetric matrix, do we have such a distance? Note that $A$ is the same for all the time series we want to compare.
-
Actually the distance for posdef matrices is: $\|\log(M^{-1/2}NM^{-1/2})\|_F$... –  Suvrit Sep 27 '12 at 10:12
I don't know if that is a natural distance, but a non-boring choice is given by mapping skew-Hermitian matrices to unitary matrices by using the exponential map, and then just using the Riemannian distance in the mapped space. –  Suvrit Sep 27 '12 at 10:22

Since skew-Hermitian matrices form the Lie algebra of the unitary group $U(n)$, the space has a natural positive definite inner product given by $$(A, B) = - tr (AB).$$ This inner product, of course, defines a distance. The inner product is invariant under conjugation by elements of $U(n)$.
Real skew-symmetric matrices form the Lie algebra of the orthogonal group. It also has a conjugation invariant positive definite inner product, in fact only one up to a scalar multiple. It is also $-tr(AB)$.
I mean, this construction should give the "trivial" norm $\left(\sum_{i,j} A_{ij}^2\right)^{1/2}$, if I am not missing something. –  Federico Poloni Sep 27 '12 at 16:18

format: plain


text:
# Trigonometric integral question

The problem was to find $\int \tan^5(x)\, \sec^7(x)\, dx$

The solution the book got was different from mine, but I'm sure I did the right steps. Since the solutions are completely different, I have a feeling they might be the same thing, but I'm not sure how I would know this. Here's what the book got:

$\sec^{11}(x)/11-2\sec^9(x)/9+\sec^7(x)/7+C$

Here's what I got: $\tan^6(x)/6 + \tan^{11}(x)/11 + C$

EDIT: So my answer is wrong then, so let me list my steps see if you can catch my mistake

$\int \tan^5(x)\sec^7(x)\, dx$

$\int \tan^4x \tan x \sec^5x \sec^2x\, dx$

$\int \tan^4 x\tan x \ (1+\tan^5x)\,\sec^2x\,dx$

$u=\tan x \ du=\sec^2x$

$\int u^4(u)(1+u^5)\,du$

$\int u^5(1+u^5)\,du$

$\int u^5+u^{10}\,du$

$=\tan^6(x)/6 + \tan^{11}(x)/11 + C$

-
$tan^5(x) + 1 \neq sec^5(x)$. –  Zarrax Dec 5 '10 at 22:43
Ya youre right :) –  maq Dec 5 '10 at 23:14

If they differ by a constant then their difference should be constant. You can check that this is not so by setting $x=0$ and $x=\pi.$

-
The difference of what? Both equations? I'm not understanding what you mean –  maq Dec 5 '10 at 22:03
@f-prime The first answer minus the second. Note that the first answer switches sign when we put in $x=\pi$ instead of $x=0.$ –  Derek Jennings Dec 5 '10 at 22:07
The difference of the two solutions. At zero, your solution is C, while the book's solution is 1/11-2/9+1/7+C'. At pi, your solution is again C, while the book's is -(1/11-2/9+1/7)+C'. C'-C is not consistent between these, so they differ. –  Ross Millikan Dec 5 '10 at 22:07
But if I plug both of these in Wolframalpha for say x=5, the book solution comes out to .47 and my solution comes out to 7.47, so they differ by a constant of 7, no? Or am I misunderstanding the concept of differing by a constant? –  maq Dec 5 '10 at 22:11
Ignoring $C$ the second is $0$ for both $x=0$ and $x=\pi$ but the first changes from $8/693$ to $-8/693$ so their difference cannot be constant. –  Derek Jennings Dec 5 '10 at 22:11

Instead of working with $\tan$ ,$\sec$ , use their $\sin \text {and} \cos$ definitions in their place, the problem will be reduced to reverse application of product rule. way easier than to play around with than $\tan$ and $\sec$ .

-

Here's a hint: calculate the derivative of $\sec^n(x)$ for integer n > 0, then think how you can use this , and the fact that $\tan^2(x) = 1 + \sec^2(x)$, to calculate the integral.

-


text:
Home Parsing stops with Akka Streams mapAsync

# Parsing stops with Akka Streams mapAsync

user6719
1#
user6719 Published in September 21, 2018, 8:02 am

I am parsing 50000 records which contain their titles and URLs on the web page. While parsing, I am writing them to the database, which is PostgreSQL. I deployed my application using docker-compose. However, it keeps stopping on some page without any reason. I tried to write some logs to figure out what's happening, but there is no connection error or anything like that.

Here is my code for parsing and writing to the database:

object App {
val browser = JsoupBrowser()
val catRepo = new CategoryRepo(db)
val torrentRepo = new TorrentRepo(db)
val torrentForParseRepo = new TorrentForParseRepo(db)
val parallelismFactor = 10
val groupFactor = 10
implicit val system = ActorSystem("TolokaParser")
implicit val materializer = ActorMaterializer()
implicit val executionContext = system.dispatcher

def parseAndWriteTorrentsForParseToDb(doc: App.browser.DocumentType) = {
Source(getRecordsLists(doc))
.grouped(groupFactor)
.mapAsync(parallelismFactor) { torrentForParse: Seq[TorrentForParse] =>
torrentForParseRepo.createInBatch(torrentForParse)
}
.runWith(Sink.ignore)
}

def getRecordsLists(doc: App.browser.DocumentType) = {
val pages = generatePagesFromHomePage(doc)
println(pages.size)
val result = for {
page <- pages
} yield {
println(s"Parsing torrent list...\$page")
println(tmp.size)
tmp
}
result flatten
}

}

What may be the cause of such problems?

• From the .runWith(Sink.ignore), you got a Future. Do you handle if there is any exception? – Luca T. Feb 13 at 20:01


text:
## Intermediate Algebra (12th Edition)

$5\sqrt{10}-\sqrt{30}$
$\bf{\text{Solution Outline:}}$ To simplify the given radical expression, $\sqrt{10}(5-\sqrt{3}) ,$ use the Distributive Property and the properties of radicals. $\bf{\text{Solution Details:}}$ Using the Distributive Property which is given by $a(b+c)=ab+ac,$ the expression above is equivalent to \begin{array}{l}\require{cancel} \sqrt{10}(5)-\sqrt{10}(\sqrt{3}) \\\\= 5\sqrt{10}-\sqrt{10}(\sqrt{3}) .\end{array} Using the Product Rule of radicals which is given by $\sqrt[m]{x}\cdot\sqrt[m]{y}=\sqrt[m]{xy},$ the expression above is equivalent to\begin{array}{l}\require{cancel} 5\sqrt{10}-\sqrt{10(3)} \\\\= 5\sqrt{10}-\sqrt{30} .\end{array}


text:
Calculus: Early Transcendentals 8th Edition

Published by Cengage Learning

Chapter 11 - Section 11.1 - Sequences - 11.1 Exercises: 34

Answer

The sequence converges to $e^2.$

Work Step by Step

By continuity of limits we may take the limit to the exponent of $e$. The limit of $\frac{2n}{n + 2}$ is 2. Hence the sequence converges to $e^2.$

After you claim an answer you’ll have 24 hours to send in a draft. An editor will review the submission and either publish your submission or provide feedback.


text:
# Limit of square root problem

Can you please help me out with this limit problem. Actually, I tried to solve it by the conjugate method but it didn't work with me.

Thank you.

$$\lim_{x \to 0}\; \bigg( \frac{1}{\sqrt{x}} - \frac{1}{\sqrt{x²+x}} \bigg)$$

• I edited your question. Please check and make sure that I did not alter what you are asking. – Thomas Jan 24 '13 at 15:13
• what was the result from your conjugate method? – still_learning Jan 24 '13 at 15:15
• The limit is not defined as the function is not defined in a deleted neighbourhood of $0$. The function is defined on $(0, \infty)$ so you could instead consider the corresponding one-sided limit. – Michael Albanese Jan 24 '13 at 15:41

$$\lim_{x \to 0} \frac{\sqrt{x^2+x} - \sqrt{x}}{\sqrt{x(x^2+x)}}= \lim_{x \to 0} \frac{\sqrt{x}(\sqrt{x+1} - 1)}{x\sqrt{x+1}}= \lim_{x \to 0} \frac{x^{\frac{3}{2}}}{x\sqrt{x+1}(\sqrt{x+1}+1)}=0$$ The third step is due to mupltiplying both numerator and denominator by $\sqrt{x+1}+1$
Take $\frac{1}{\sqrt{x}}$ common and then try the conjugate method.
Also, $$\dfrac{1}{\sqrt{x}}-\dfrac{1}{\sqrt{x^2+x}}=\dfrac{1}{\sqrt{x}}\left(1-(1+x)^{-1/2}\right)=\dfrac{1}{\sqrt{x}}\left(\dfrac{1}{2}x+o(x)\right)\to 0 \mbox{ as } x\to 0^+$$


text:
# On the groups of order $p(p^2+1)$

Let $G$ be a group of order $p(p^2+1)$, where $p$ is an odd prime number and $p>3$. Easily we can see that $G$ is solvable and so $G$ has a Hall subgroup $L$ of order $p^2+1$. Also we know that $P$, the Sylow subgroup of $G$ is a normal subgroup of $G$. Is it true in general that $L$ is a normal subgroup of $G$?

As Jeremy Rickard points out, the answer is no in general. However, $G$ has order divisible by $2,$ but not by $4.$ It follows that $G$ has a normal $2$-complement $K$ of order $p \left( \frac{p^{2}+1}{2} \right).$ Now $K$ has a normal $p$-complement by Burnside's transfer theorem, since ${\rm gcd}(p-1,\frac{p^{2}+1}{2}) = 1.$ This subgroup of $K$ has order $\frac{p^{2}+1}{2}$ and is characteristic in $K,$ hence normal in $G.$ Thus there is a subgroup of index $2$ in $L$ which is normal in $G.$
• I guess a slightly easier argument, using the normality of $P$, is: $L/\text{C}_L(P)$ is a subgroup of $\text{Aut}(P)=C_{p-1}$. But $\text{gcd}(p-1,\lvert L\rvert)=2$, so $[L:\text{C}_L(P)]\le2$. – Peter Mueller May 8 '14 at 13:56
• Yes, marginally easier. I had forgotten that $P$ was normal, so Burnside's transfer theorem certainly wasn't necessary. – Geoff Robinson May 8 '14 at 13:57
No. For example, take the direct product of a dihedral group of order $2p$ and a cyclic group of order $(p^2+1)/2$.


text:
location:  Publications → journals → CMB
Abstract view

# On the Structure of Cuntz Semigroups in (Possibly) Nonunital C*-algebras

Published:2015-03-18
Printed: Jun 2015
• Aaron Peter Tikuisis,
Institute of Mathematics, University of Aberdeen, Aberdeen, United Kingdom
• Andrew Toms,
Department of Mathematics, Purdue University, 150 North University Street, West Lafayette, IN 47907, USA
 Format: LaTeX MathJax PDF

## Abstract

We examine the ranks of operators in semi-finite $\mathrm{C}^*$-algebras as measured by their densely defined lower semicontinuous traces. We first prove that a unital simple $\mathrm{C}^*$-algebra whose extreme tracial boundary is nonempty and finite contains positive operators of every possible rank, independent of the property of strict comparison. We then turn to nonunital simple algebras and establish criteria that imply that the Cuntz semigroup is recovered functorially from the Murray-von Neumann semigroup and the space of densely defined lower semicontinuous traces. Finally, we prove that these criteria are satisfied by not-necessarily-unital approximately subhomogeneous algebras of slow dimension growth. Combined with results of the first-named author, this shows that slow dimension growth coincides with $\mathcal Z$-stability, for approximately subhomogeneous algebras.
 Keywords: nuclear C*-algebras, Cuntz semigroup, dimension functions, stably projectionless C*-algebras, approximately subhomogeneous C*-algebras, slow dimension growth
 MSC Classifications: 46L35 - Classifications of $C^*$-algebras 46L05 - General theory of $C^*$-algebras 46L80 - $K$-theory and operator algebras (including cyclic theory) [See also 18F25, 19Kxx, 46M20, 55Rxx, 58J22] 47L40 - Limit algebras, subalgebras of $C^*$-algebras 46L85 - Noncommutative topology [See also 58B32, 58B34, 58J22]

 top of page | contact us | privacy | site map |


text:
# Minkowski space

In physics and mathematics, Minkowski space (or Minkowski spacetime) is the mathematical setting in which Einstein's theory of special relativity is most conveniently formulated. In this setting the three ordinary dimensions of space are combined with a single dimension of time to form a four-dimensional manifold for representing a spacetime. Minkowski space is named for the German mathematician Hermann Minkowski (See History below).

## Structure

Formally, Minkowski space is a four-dimensional real vector space equipped with a nondegenerate, symmetric bilinear form with signature (−,+,+,+) (Some may also prefer the alternative signature (+,-,-,-)). Elements of Minkowski space are called events or four-vectors. Minkowski space is often denoted R1,3 to emphasize the signature, although it is also denoted M 4 or simply M.

### The Minkowski inner product

This inner product is similar to the usual, Euclidean, inner product, but is used to describe a different geometry; the geometry usually associated with relativity. Let ${\displaystyle M}$ be a 4-dimensional real vector space. The Minkowski inner product is a map ${\displaystyle \eta :M\times M\rightarrow \mathbb {R} }$ (i.e. given any two vectors ${\displaystyle V,W}$ in ${\displaystyle M}$ we define ${\displaystyle \eta (V,W)}$ as a real number) which satisfies properties (1), (2), (3) listed here, as well as property (4) given below:

1.  bilinear: ${\displaystyle \eta (aU+V,W)\,=a\eta (U,W)+\eta (V,W)}$, ( ${\displaystyle \forall a\in \mathbb {R} }$ and ${\displaystyle \forall U,V,W\in M}$)

2.  symmetric: ${\displaystyle \eta (V,W)\,=\eta (W,V)}$ (${\displaystyle \forall V,W\in M}$)

3.  nondegenerate: if ${\displaystyle \eta (V,W)\,=0}$ ${\displaystyle \forall W\in M}$, then ${\displaystyle V\,=0}$,

Note that this is not an inner product in the usual sense, since it is not positive-definite, i.e. the Minkowski norm of a vector ${\displaystyle V}$, defined as ${\displaystyle V^{2}\,=\eta (V,V)}$, need not be positive. The positive-definite condition has been replaced by the weaker condition of nondegeneracy (every positive-definite form is nondegenerate but not vice-versa).The inner product is said to be indefinite.

Just as in Euclidean space, two vectors are said to be orthogonal if ${\displaystyle \eta (V,W)\,=0}$. But there is a paradigm shift in Minkowski space to include hyperbolic-orthogonal events in case V and W span a plane where ${\displaystyle \eta }$ takes negative values. This shift to a new paradigm is clarified by comparing the Euclidean structure of the ordinary complex number plane to the structure of the plane of split-complex numbers.

A vector ${\displaystyle V}$ is called a unit vector if ${\displaystyle V^{2}=\pm 1}$. A basis for M consisting of mutually orthogonal unit vectors is called an orthonormal basis.

There is a theorem stating that any inner product space satisfying conditions 1 to 3 above always has an orthonormal basis. Furthermore, the theorem states that the number of positive and negative unit vectors in any such basis is fixed. This pair of numbers is called the signature of the inner product.

Then the fourth condition on ${\displaystyle \eta }$ can be stated:

4.  The inner product ${\displaystyle \eta }$ has signature (-,+,+,+)

### Standard basis

A standard basis for Minkowski space is a set of four mutually orthogonal vectors (e0, e1, e2, e3) such that

${\displaystyle -\left(e_{0}\right)^{2}=(e_{1})^{2}=(e_{2})^{2}=(e_{3})^{2}=1}$

These conditions can be written compactly in the following form:

${\displaystyle \langle e_{\mu },e_{\nu }\rangle =\eta _{\mu \nu }}$

where μ and ν run over the values (0, 1, 2, 3) and the matrix η is given by

${\displaystyle \eta ={\begin{pmatrix}-1&0&0&0\\0&1&0&0\\0&0&1&0\\0&0&0&1\end{pmatrix}}}$

Relative to a standard basis, the components of a vector ${\displaystyle V}$ are written ${\displaystyle (V^{0},V^{1},V^{2},V^{3})}$ and we use the Einstein notation to write V = Vμeμ. The component ${\displaystyle V^{0}}$ is called the timelike component of ${\displaystyle V}$ while the other three components are called the spatial components.

In terms of components, the inner product between two vectors ${\displaystyle V}$ and ${\displaystyle W}$ is given by

${\displaystyle \langle V,W\rangle =\eta _{\mu \nu }V^{\mu }W^{\nu }=-V^{0}W^{0}+V^{1}W^{1}+V^{2}W^{2}+V^{3}W^{3}}$

and the norm-squared of a vector ${\displaystyle V}$ is

${\displaystyle V^{2}=\eta _{\mu \nu }V^{\mu }V^{\nu }=-(V^{0})^{2}+(V^{1})^{2}+(V^{2})^{2}+(V^{3})^{2}.\,}$

## Alternative definition

The section above defines Minkowski space as a vector space. There is an alternative definition of Minkowski space as an affine space which views Minkowski space as a homogeneous space of the Poincaré group with the Lorentz group as the stabilizer. See Erlangen program.

## Causal structure

Main article: Causal structure

Four-vectors are classified according to the sign of their (Minkowski) inner product. For four-vectors, ${\displaystyle U}$, ${\displaystyle V}$ and ${\displaystyle W}$, the classification is as follows:

• ${\displaystyle V}$ is timelike if and only if ${\displaystyle \eta _{\mu \nu }V^{\mu }V^{\nu }\,=V^{\mu }V_{\mu }<0}$
• ${\displaystyle U}$ is spacelike if and only if ${\displaystyle \eta _{\mu \nu }U^{\mu }U^{\nu }\,=U^{\mu }U_{\mu }>0}$
• ${\displaystyle W}$ is null (lightlike) if and only if ${\displaystyle \eta _{\mu \nu }W^{\mu }W^{\nu }\,=W^{\mu }W_{\mu }=0}$

This terminology comes from the use of Minkowski space in the theory of relativity. The set of all null vectors at an event of Minkowski space constitutes the light cone of that event. Note that all these notions are independent of the frame of reference.

Vector fields are called timelike, spacelike or null if the associated vectors are timelike, spacelike or null at each point where the field is defined.

A useful result regarding null vectors is that if two null vectors are orthogonal (zero inner product), then they must be proportional.

Once a direction of time is chosen, timelike and null vectors can be further decomposed into various classes. For timelike vectors we have

1. future directed timelike vectors whose first component is positive, and
2. past directed timelike vectors whose first component is negative.

Null vectors fall into three class:

1. the zero vector, whose components in any basis are (0,0,0,0),
2. future directed null vectors whose first component is positive, and
3. past directed null vectors whose first component is negative.

Together with spacelike vectors there are 6 classes in all.

An orthonormal basis for Minkowski space necessarily consists of one timelike and three spacelike unit vectors. If one wishes to work with non-orthonormal bases it is possible to have other combinations of vectors. For example, one can easily construct a (non-orthonormal) basis consisting entirely of null vectors, called a null basis.

## Causality relations

Let ${\displaystyle x,y\in M}$

We say that

1. ${\displaystyle x}$ chronologically precedes ${\displaystyle y}$ if y-x is future directed timelike.
2. ${\displaystyle x}$ causally precedes ${\displaystyle y}$ if y-x is future directed null

## Reversed triangle inequality

If ${\displaystyle V_{1}}$ and ${\displaystyle V_{2}}$ are two equally directed timelike four-vectors then

${\displaystyle |V_{1}+V_{2}|\geq |V_{1}|+|V_{2}|}$

where

${\displaystyle |V|:={\sqrt {-\eta _{\mu \nu }V^{\mu }V^{\nu }}}}$

## Locally flat spacetime

Strictly speaking, the use of the Minkowski space to describe physical systems over finite distances applies only in the Newtonian limit of systems without significant gravitation. In the case of significant gravitation, spacetime becomes curved and one must abandon special relativity in favor of the full theory of general relativity.

Nevertheless, even in such cases, Minkowski space is still a good description in an infinitesimally small region surrounding any point (barring gravitational singularities). More abstractly, we say that in the presence of gravity spacetime is described by a curved 4-dimensional manifold for which the tangent space to any point is a 4-dimensional Minkowski space. Thus, the structure of Minkowski space is still essential in the description of general relativity.

In the limit of weak gravity, spacetime becomes flat and looks globally, not just locally, like Minkowski space. For this reason Minkowski space is often referred to as flat spacetime.

## History

Minkowski space is named for the German mathematician Hermann Minkowski, who around 1907 realized that the theory of special relativity (previously developed by Einstein) could be elegantly described using a four-dimensional spacetime, which combines the dimension of time with the three dimensions of space.

“The views of space and time which I wish to lay before you have sprung from the soil of experimental physics, and therein lies their strength. They are radical. Henceforth space by itself, and time by itself, are doomed to fade away into mere shadows, and only a kind of union of the two will preserve an independent reality.” – Hermann Minkowski, 1908

The way had been prepared for Minkowski's space by the development of hyperbolic quaternions in the 1890s. In fact, as a mathematical structure, Minkowski space can be taken as hyperbolic quaternions, minus the multiplicative product, and retaining only the bilinear form

η(p,q) = −(pq* + (pq*)*)/2

which is generated by the hyperbolic quaternion product pq*.


text:
# Loop Subdivision

For an in-practice example, see the User Guide.

Loop subdivision (named after Charles Loop) is a standard approximating subdivision scheme for triangle meshes. At a high level, it consists of two basic steps:

1. Split each triangle into four by connecting edge midpoints (sometimes called “$$4-1$$ subdivision”).
2. Update vertex positions as a particular weighted average of neighboring positions.

The $$4-1$$ subdivision looks like this:

And the following picture illustrates the weighted average:

Note that the above image has two separate formualas.

On the right side, the new position of an old vertex is the following:

$v_{new} = (1 - nu) \cdot v_{old} + u \cdot \sum v_{neighbor}$

On the left side, the new position of a newly created vertex v that splits the old Edge $$AB$$ and is flanked by old opposite vertices $$C$$ and $$D$$ across the two faces connected to $$AB$$ in the original mesh is the following:

$v_{new} = \frac{3}{8} \cdot (A + B) + \frac{1}{8} \cdot (C + D).$

If we repeatedly apply these two steps, we will converge to a fairly smooth approximation of our original mesh.

We will implement Loop subdivision as the Halfedge_Mesh::loop_subdivide() method. In contrast to linear and Catmull-Clark subdivision, Loop subdivision must be implemented using the local mesh operations described above (simply because it provides an alternative perspective on subdivision implementation, which can be useful in different scenarios). In particular, $$4-1$$ subdivision can be achieved by applying the following strategy:

1. Split every edge of the mesh in any order whatsoever.
2. Flip any new edge that touches a new vertex and an old vertex.

The following pictures (courtesy Denis Zorin) illustrate this idea:

Notice that only blue (and not black) edges are flipped in this procedure; as described above, edges in the split mesh should be flipped if and only if they touch both an original vertex and a new vertex (i.e., a midpoint of an original edge).

When working with dynamic mesh data structures (like a halfedge mesh), one must think very carefully about the order in which mesh elements are processed—it is quite easy to delete an element at one point in the code, then try to access it later (typically resulting in a crash!). For instance, suppose we write a loop like this:

// iterate over all edges in the mesh
for (EdgeRef e = edges_begin(); e != edges_end(); e++) {
if (some condition is met) {
split_edge(e);
}
}

Although this routine looks straightforward, it can very easily crash! The reason is fairly subtle: we are iterating over edges in the mesh by incrementing the iterator e (via the expression e++). But since split_edge() is allowed to create and delete mesh elements, it might deallocate the edge pointed to by e before we increment it! To be safe, one should instead write a loop like this:

// iterate over all edges in the mesh
int n = n_edges();
EdgeRef e = edges_begin();
for (int i = 0; i < n; i++) {

// get the next edge NOW!
EdgeRef nextEdge = e;
nextEdge++;

// now, even if splitting the edge deletes it...
if (some condition is met) {
split_edge(e);
}

// ...we still have a valid reference to the next edge.
e = nextEdge;
}

Note that this loop is just a representative example, the implementer must consider which elements might be affected by a local mesh operation when writing such loops. We recommend ensuring that your atomic edge operations provide certain guarantees. For instance, if the implementation of Halfedge_Mesh::flip_edge() guarantees that no edges will be created or destroyed (as it should), then you can safely do edge flips inside a loop without worrying about these kinds of side effects.

For Loop subdivision, there are some additional data members that will make it easy to keep track of the data needed to update the connectivity and vertex positions. In particular:

• Vertex::new_pos can be used as temporary storage for the new position (computed via the weighted average above). Note that one should not change the value of Vertex::pos until all the new vertex positions have been computed – otherwise, subsequent computation will take averages of values that have already been averaged!
• Likewise, Edge::new_pos can be used to store the position of the vertices that will ultimately be inserted at edge midpoints. Again, these values should be computed from the original values (before subdivision), and applied to the new vertices only at the very end. The Edge::new_pos value will be used for the position of the vertex that will appear along the old edge after the edge is split. We precompute the position of the new vertex before splitting the edges and allocating the new vertices because it is easier to traverse the simpler original mesh to find the positions for the weighted average that determines the positions of the new vertices.
• Vertex::is_new can be used to flag whether a vertex was part of the original mesh, or is a vertex newly inserted by subdivision (at an edge midpoint).
• Edge::is_new likewise flags whether an edge is a piece of an edge in the original mesh, or is an entirely new edge created during the subdivision step.

Given this setup, we strongly suggest that it will be easiest to implement subdivision according to the following “recipe” (though the implementer is of course welcome to try doing things a different way!). The basic strategy is to first compute the new vertex positions (storing the results in the new_pos members of both vertices and edges), and only then update the connectivity. Doing it this way will be much easier, since traversal of the original (coarse) connectivity is much simpler than traversing the new (fine) connectivity. In more detail:

1. Mark all vertices as belonging to the original mesh by setting Vertex::is_new to false for all vertices in the mesh.
2. Compute updated positions for all vertices in the original mesh using the vertex subdivision rule, and store them in Vertex::new_pos.
3. Compute new positions associated with the vertices that will be inserted at edge midpoints, and store them in Edge::new_pos.
4. Split every edge in the mesh, being careful about how the loop is written. In particular, you should make sure to iterate only over edges of the original mesh. Otherwise, the loop will keep splitting edges that you just created!
5. Flip any new edge that connects an old and new vertex.
6. Finally, copy the new vertex positions (Vertex::new_pos) into the usual vertex positions (Vertex::pos).

It may be useful to ensure Halfedge_Mesh::split_edge() will now return an iterator to the newly inserted vertex, and particularly that the halfedge of this vertex will point along the edge of the original mesh. This iterator is useful because it can be used to

1. Flag the vertex returned by the split operation as a new vertex, and
2. Flag each outgoing edge as either being new or part of the original mesh.

(In other words, Step $$4$$ is a great time to set the members is_new for vertices and edges created by the split. It is also a good time to copy the new_pos field from the edge being split into the new_pos field of the newly inserted vertex.)

We recommend implementing this algorithm in stages, e.g., first see if you can correctly update the connectivity, then worry about getting the vertex positions right. Some examples below illustrate the correct behavior of the algorithm (coming soon).

This subdivision rule is not required to support meshes with boundary, unless the implementer wishes to go above and beyond.


text:
# Counting the powers

• Let $$a$$ be the remainder of $$\large {{3}}^{1234567890}$$ upon division by 8.

• Similarly let $$b$$ be the remainder of $$\large { {5}}^{1234567890}$$ upon division by 6.

Then, what is $$a+b$$?

###### Want some interesting questions like this?. Enter the world where Calculators will not help
×

Problem Loading...

Note Loading...

Set Loading...


text:
# Could someone please explain this 4-vector/tensor notation?

#### AxiomOfChoice

If you can answer any of the questions below, your help will be greatly appreciated.

There's an equation from E&M (I believe the definition of the antisymmetric field tensor) that reads:

$$F_{\mu \nu} = \frac{\partial A_\nu}{\partial x^\mu} - \frac{\partial A_\mu}{\partial x^\nu},$$

where (of course) $A$ is the 4-vector potential. I have no idea how to parse this equation...what's going on with taking the partial of $A_\nu$ with respect to $x^\mu$? What's this notation describing, or telling me to do? I just don't see it.

Also (and this pertains to relativistic quantum mechanics), what's meant by something like

$$\partial_\mu [\partial_\nu \Psi(x^\mu)],$$

where (of course) $\Psi(x^\mu)$ is the wave function? I.e., what does it mean to operate on $\partial_\nu$ of something with $\partial_\mu$? Particularly when that something I'm operating on is a function of $x^\mu$? (By the way: In case the notation is unfamiliar to you, $\partial^\mu = \partial / \partial x_\mu$.) Does that turn into something? Can I compactify that? Or do I just have to leave it as $\partial_\mu [\partial_\nu \Psi(x^\mu)]$? Also, would I get an equivalent expression if I interchanged the order of $\partial_\mu$ and $\partial_\nu$; i.e., if I tried to evaluate $\partial_\nu [\partial_\mu \Psi(x^\mu)]$? Or would I get something quite different?

Does all of this boil down to "we need two distinct dummy indices, $\mu$ and $\nu$, to indicate that there shouldn't be any summation going on?"

(P.S. - I would like to thank David J. Griffiths for getting me into the habit of italicizing words I want to emphasize.)

Related General Physics News on Phys.org

#### Peeter

$$F_{\mu \nu} = \frac{\partial A_\nu}{\partial x^\mu} - \frac{\partial A_\mu}{\partial x^\nu},$$

where (of course) $A$ is the 4-vector potential. I have no idea how to parse this equation...what's going on with taking the partial of $A_\nu$ with respect to $x^\mu$?
Given two four vectors, one for the field, and one for the spacetime
position

$$\vec{A} = (A_0, -A_1, -A_2, -A_3)$$
$$\vec{x} = (x^0, x^1, x^2, x^3) = (ct, x, y, z)$$

This says that there's 16 scalar quantities that can be calculated by
taking derivatives. Two examples are:

$$F_{23} = \frac{\partial A_3}{\partial x^2} - \frac{\partial A_2}{\partial x^3} = \frac{\partial A_3}{\partial y} - \frac{\partial A_2}{\partial z}$$

$$F_{33} = \frac{\partial A_3}{\partial x^3} - \frac{\partial A_3}{\partial x^3} = 0$$

For your other question, I'd assume summation over $\mu$ is implied.

#### AxiomOfChoice

Thanks a lot for your help!

What if I confront something like

$$\frac{\partial F^{\mu \nu}}{\partial x^\nu} = \partial_\nu F^{\mu \nu}?$$

Does that imply a sum over $\nu$?

#### nicksauce

Science Advisor
Homework Helper
Yes, if an index is repeated as an upper index and a lower index, it implies a sum over that index.

### Want to reply to this thread?

"Could someone please explain this 4-vector/tensor notation?"

### Physics Forums Values

We Value Quality
• Topics based on mainstream science
• Proper English grammar and spelling
We Value Civility
• Positive and compassionate attitudes
• Patience while debating
We Value Productivity
• Disciplined to remain on-topic
• Recognition of own weaknesses
• Solo and co-op problem solving


text:
F07 Chapter Contents
F07 Chapter Introduction
NAG Library Manual

# NAG Library Routine DocumentF07PJF (DSPTRI)

Note:  before using this routine, please read the Users' Note for your implementation to check the interpretation of bold italicised terms and other implementation-dependent details.

## 1  Purpose

F07PJF (DSPTRI) computes the inverse of a real symmetric indefinite matrix $A$, where $A$ has been factorized by F07PDF (DSPTRF), using packed storage.

## 2  Specification

 SUBROUTINE F07PJF ( UPLO, N, AP, IPIV, WORK, INFO)
 INTEGER N, IPIV(*), INFO REAL (KIND=nag_wp) AP(*), WORK(N) CHARACTER(1) UPLO
The routine may be called by its LAPACK name dsptri.

## 3  Description

F07PJF (DSPTRI) is used to compute the inverse of a real symmetric indefinite matrix $A$, the routine must be preceded by a call to F07PDF (DSPTRF), which computes the Bunch–Kaufman factorization of $A$, using packed storage.
If ${\mathbf{UPLO}}=\text{'U'}$, $A=PUD{U}^{\mathrm{T}}{P}^{\mathrm{T}}$ and ${A}^{-1}$ is computed by solving ${U}^{\mathrm{T}}{P}^{\mathrm{T}}XPU={D}^{-1}$.
If ${\mathbf{UPLO}}=\text{'L'}$, $A=PLD{L}^{\mathrm{T}}{P}^{\mathrm{T}}$ and ${A}^{-1}$ is computed by solving ${L}^{\mathrm{T}}{P}^{\mathrm{T}}XPL={D}^{-1}$.

## 4  References

Du Croz J J and Higham N J (1992) Stability of methods for matrix inversion IMA J. Numer. Anal. 12 1–19

## 5  Parameters

1:     UPLO – CHARACTER(1)Input
On entry: specifies how $A$ has been factorized.
${\mathbf{UPLO}}=\text{'U'}$
$A=PUD{U}^{\mathrm{T}}{P}^{\mathrm{T}}$, where $U$ is upper triangular.
${\mathbf{UPLO}}=\text{'L'}$
$A=PLD{L}^{\mathrm{T}}{P}^{\mathrm{T}}$, where $L$ is lower triangular.
Constraint: ${\mathbf{UPLO}}=\text{'U'}$ or $\text{'L'}$.
2:     N – INTEGERInput
On entry: $n$, the order of the matrix $A$.
Constraint: ${\mathbf{N}}\ge 0$.
3:     AP($*$) – REAL (KIND=nag_wp) arrayInput/Output
Note: the dimension of the array AP must be at least $\mathrm{max}\phantom{\rule{0.125em}{0ex}}\left(1,{\mathbf{N}}×\left({\mathbf{N}}+1\right)/2\right)$.
On entry: the factorization of $A$ stored in packed form, as returned by F07PDF (DSPTRF).
On exit: the factorization is overwritten by the $n$ by $n$ matrix ${A}^{-1}$.
More precisely,
• if ${\mathbf{UPLO}}=\text{'U'}$, the upper triangle of ${A}^{-1}$ must be stored with element ${A}_{ij}$ in ${\mathbf{AP}}\left(i+j\left(j-1\right)/2\right)$ for $i\le j$;
• if ${\mathbf{UPLO}}=\text{'L'}$, the lower triangle of ${A}^{-1}$ must be stored with element ${A}_{ij}$ in ${\mathbf{AP}}\left(i+\left(2n-j\right)\left(j-1\right)/2\right)$ for $i\ge j$.
4:     IPIV($*$) – INTEGER arrayInput
Note: the dimension of the array IPIV must be at least $\mathrm{max}\phantom{\rule{0.125em}{0ex}}\left(1,{\mathbf{N}}\right)$.
On entry: details of the interchanges and the block structure of $D$, as returned by F07PDF (DSPTRF).
5:     WORK(N) – REAL (KIND=nag_wp) arrayWorkspace
6:     INFO – INTEGEROutput
On exit: ${\mathbf{INFO}}=0$ unless the routine detects an error (see Section 6).

## 6  Error Indicators and Warnings

Errors or warnings detected by the routine:
${\mathbf{INFO}}<0$
If ${\mathbf{INFO}}=-i$, the $i$th parameter had an illegal value. An explanatory message is output, and execution of the program is terminated.
${\mathbf{INFO}}>0$
If ${\mathbf{INFO}}=i$, $d\left(i,i\right)$ is exactly zero; $D$ is singular and the inverse of $A$ cannot be computed.

## 7  Accuracy

The computed inverse $X$ satisfies a bound of the form
• if ${\mathbf{UPLO}}=\text{'U'}$, $\left|D{U}^{\mathrm{T}}{P}^{\mathrm{T}}XPU-I\right|\le c\left(n\right)\epsilon \left(\left|D\right|\left|{U}^{\mathrm{T}}\right|{P}^{\mathrm{T}}\left|X\right|P\left|U\right|+\left|D\right|\left|{D}^{-1}\right|\right)$;
• if ${\mathbf{UPLO}}=\text{'L'}$, $\left|D{L}^{\mathrm{T}}{P}^{\mathrm{T}}XPL-I\right|\le c\left(n\right)\epsilon \left(\left|D\right|\left|{L}^{\mathrm{T}}\right|{P}^{\mathrm{T}}\left|X\right|P\left|L\right|+\left|D\right|\left|{D}^{-1}\right|\right)$,
$c\left(n\right)$ is a modest linear function of $n$, and $\epsilon$ is the machine precision.

## 8  Further Comments

The total number of floating point operations is approximately $\frac{2}{3}{n}^{3}$.
The complex analogues of this routine are F07PWF (ZHPTRI) for Hermitian matrices and F07QWF (ZSPTRI) for symmetric matrices.

## 9  Example

This example computes the inverse of the matrix $A$, where
 $A= 2.07 3.87 4.20 -1.15 3.87 -0.21 1.87 0.63 4.20 1.87 1.15 2.06 -1.15 0.63 2.06 -1.81 .$
Here $A$ is symmetric indefinite, stored in packed form, and must first be factorized by F07PDF (DSPTRF).

### 9.1  Program Text

Program Text (f07pjfe.f90)

### 9.2  Program Data

Program Data (f07pjfe.d)

### 9.3  Program Results

Program Results (f07pjfe.r)


text:
# Tangential Acceleration and Gravity in a moving car

1. Feb 2, 2014

### Conservation

1. The problem statement, all variables and given/known data
A car is driven at a constant speed of 10.0 m/s as it travels over a circular-shaped arch. If the radius of curvature of the bridge is 50.0m, what upward force does the car exert on the 64.0 kg person riding in the car as it passes over the bridge?

2. Relevant equations
v2/r=ac
Fman on car=Fcar on man
Fg=mag

3. The attempt at a solution
The centripetal acceleration is towards the center, or down towards the bottom of the arched bridge. Similarly, the man's weight is exerted downwards. Both of these forces contribute to the Fman on car.

Hence, Fman on car=mag+mv2/r, making the answer 755.84 N. However, the answer key says that the mag and the mv2/r are in different directions, making the answer 499.84 N instead. Any help on this would be greatly appreciated.

Last edited: Feb 2, 2014
2. Feb 2, 2014

### jackarms

They are in fact in different directions, so I don't know what the solution means. But for the answer make a free-body diagram.

$∑F_{y} = F - mg = -ma$

So $F$ in fact equals $mg - ma$

The error in your reasoning is that the quantity mv^2/r, the centripetal acceleration, is not provided by a separate force -- the weight force provides it, so the relationship changes. Also, it's not tangential acceleration, but instead centripetal acceleration, because it points inward.

3. Feb 2, 2014

### Conservation

Wow, my apologies. I meant to say centripetal-I have no idea why I said tangential.

I don't understand what you mean by the fact that the weight force "provides the centripetal acceleration." Could you elaborate on the topic?

Also, why are they different directions? Aren't both gravitational weight and centripetal acceleration towards the center, or below the bridge?

Thank you.

4. Feb 2, 2014

### jackarms

No problem -- I do it all the time.

Think about it in terms of Newton's second: $F = ma$

Essentially this means that forces provide accelerations, and accelerations need forces to produce them. So the centripetal acceleration needs a force to produce it, and this is the weight force. Centripetal forces are what provide centripetal accelerations, so in this case weight force also acts as the centripetal force. Mathematically, the quantities go on separate sides of the equation, which is how you get that negative sign in the answer. That's why even though they're in the same direction, their magnitudes don't add -- they're different quantities.

EDIT: Sorry, I meant in my first post to say that weight force and acceleration are in the same direction -- just mathematically they end up opposite one another.

Last edited: Feb 2, 2014


text:
# Tag Info

1

I don't know the specific context that you may be looking for, but it's quite common to use a four-point correlation function of the quantum dipole moment operator to retrieve non-linear relaxation dynamics. These correlation functions make up the nonlinear response function of a material system to an electric field which, when convolved with the excitation ...

1

I found it very difficult to understand your question, but here is an attempt at answering it: The whole point of embedding is to uncover the phase-space structure or, with other words, something that is topologically equivalent to the attractor. For any interesting system, this is not describable by your usual distributions (and also it is usually not ...

1

There is something you should be careful of regarding Liouville's theorem. If there are momentum-dependent forces, then Liouville's theorem changes because phase density is no longer incompressible. Suppose we define $f_{s}$ = $f_{s}(\mathbf{x},\mathbf{p},t)$ $\equiv$ the particle distribution function of species $s$, which is non-negative, contains a ...

Top 50 recent answers are included


text:
# Chemostat

Stirred bioreactor operated as a chemostat, with a continuous inflow (the feed) and outflow (the effluent). The rate of medium flow is controlled to keep the culture volume constant.

A chemostat (from Chemical environment is static) is a bioreactor to which fresh medium is continuously added, while culture liquid is continuously removed to keep the culture volume constant.[1][2] By changing the rate with which medium is added to the bioreactor the growth rate of the microorganism can be easily controlled.

## Operation

One of the most important features of chemostats is that micro-organisms can be grown in a physiological steady state. In steady state, growth occurs at a constant rate and all culture parameters remain constant (culture volume, dissolved oxygen concentration, nutrient and product concentrations, pH, cell density, etc.). In addition environmental conditions can be controlled by the experimenter.[3] Micro-organisms grown in chemostats naturally strive to steady state: if a low amount of cells are present in the bioreactor, the cells can grow at growth rates higher than the dilution rate, as growth isn't limited by the addition of the limiting nutrient. The limiting nutrient is a nutrient essential for growth, present in the media at a limiting concentration (all other nutrients are usually supplied in surplus). However, if the cell concentration becomes too high, the amount of cells that are removed from the reactor cannot be replenished by growth as the addition of the limiting nutrient is insufficient. This results in a steady state.

### Dilution rate

At steady state the specific growth rate (μ) of the micro-organism is equal to the dilution rate (D). The dilution rate is defined as the rate of flow of medium over the volume of culture in the bioreactor

$D = \dfrac{\mbox{Medium flow rate}}{\mbox{Culture volume}} = \dfrac{\mbox{F}}{\mbox{V}}$

### Maximal growth rate

Each microorganism growing on a particular substrate has a maximum specific growth rate (μmax) (the rate of growth observed if none of the nutrients are limiting). If a dilution rate is chosen that is higher than μmax, the culture will not be able to sustain itself in the bioreactor, and will wash out. Even though maximum rates can be obtained, the reactors may become very large. This is especially true in E. coli fatty acid production in a glucose medium.

## Applications

### Research

Chemostats in research are used for investigations in cell biology, as a source for large volumes of uniform cells or protein. The chemostat is often used to gather steady state data about an organism in order to generate a mathematical model relating to its metabolic processes. Chemostats are also used as microcosms in ecology[4][5] and evolutionary biology.[6][7][8][9] In the one case, mutation/selection is a nuisance, in the other case, it is the desired process under study. Chemostats can also be used to enrich for specific types of bacterial mutants in culture such as auxotrophs or those that are resistant to antibiotics or bacteriophages for further scientific study.[10]

Competition for single and multiple resources, the evolution of resource acquisition and utilization pathways, cross-feeding/symbiosis,[11][12] antagonism, predation, and competition among predators have all been studied in ecology and evolutionary biology using chemostats.[13][14][15]

### Industry

Chemostats are frequently used in the industrial manufacturing of ethanol. In this case, several chemostats are used in series, each maintained at decreasing sugar concentrations.[citation needed]

## Concerns

• Foaming results in overflow with the volume of liquid not exactly constant.
• Some very fragile cells are ruptured during agitation and aeration.
• Cells may grow on the walls or adhere to other surfaces,[16] which is easily overcome by treating the glass walls of the vessel with a silane to render them hydrophobic.
• Mixing may not truly be uniform, upsetting the "static" property of the chemostat.
• Dripping the media into the chamber actually results in small pulses of nutrients and thus oscillations in concentrations, again upsetting the "static" property of the chemostat.
• Bacteria travel upstream quite easily. They will reach the reservoir of sterile medium quickly unless the liquid path is interrupted by an air break in which the medium falls in drops through air.

Continuous efforts to remedy each defect lead to variations on the basic chemostat quite regularly. Examples in the literature are numerous.

• Antifoaming agents are used to suppress foaming.
• Agitation and aeration can be done gently.
• Many approaches have been taken to reduce wall growth[17][18]
• Various applications use paddles, bubbling, or other mechanisms for mixing[19]
• Dripping can be made less drastic with smaller droplets and larger vessel volumes
• Many improvements target the threat of contamination

## Variations

Fermentation setups closely related to the chemostats are the turbidostat, the auxostat and the retentostat. In retentostats culture liquid is also removed from the bioreactor, but a filter retains the biomass. In this case, the biomass concentration increases until the nutrient requirement for biomass maintenance has become equal to the amount of limiting nutrient that can be consumed.

Batch culture

## References

1. ^ Novick A, Szilard L (1950). "Description of the Chemostat". Science 112 (2920): 715–6. doi:10.1126/science.112.2920.715. PMID 14787503.
2. ^ James TW (1961). "Continuous Culture of Microorganisms". Annual Review of Microbiology 15: 27–46. doi:10.1146/annurev.mi.15.100161.000331.
3. ^ D Herbert, R Elsworth Telling RC (1956). "The continuous culture of bacteria;a Theoretical and Experimental study". J. Gen. Microbiol 14 (3): 601–622. doi:10.1099/00221287-14-3-601. PMID 13346021.
4. ^ Becks L, Hilker FM, Malchow H, Jürgens K, Arndt H (2005). "Experimental demonstration of chaos in a microbial food web". Nature 435 (7046): 1226–9. doi:10.1038/nature03627. PMID 15988524.
5. ^ Pavlou S, Kevrekidis IG (1992). "Microbial predation in a periodically operated chemostat: a global study of the interaction between natural and externally imposed frequencies". Math Biosci 108 (1): 1–55. doi:10.1016/0025-5564(92)90002-E. PMID 1550993.
6. ^ Wichman HA, Millstein J, Bull JJ (2005). "Adaptive Molecular Evolution for 13,000 Phage Generations: A Possible Arms Race". Genetics 170 (1): 19–31. doi:10.1534/genetics.104.034488. PMC 1449705. PMID 15687276.
7. ^ Dykhuizen DE, Dean AM (2004). "Evolution of specialists in an experimental microcosm". Genetics 167 (4): 2015–26. doi:10.1534/genetics.103.025205. PMC 1470984. PMID 15342537.
8. ^ Wick LM, Weilenmann H, Egli T (2002). "The apparent clock-like evolution of Escherichia coli in glucose-limited chemostats is reproducible at large but not at small population sizes and can be explained with Monod kinetics". Microbiology (Reading, Engl.) 148 (Pt 9): 2889–902. PMID 12213934.
9. ^ Jones LE, Ellner SP (2007). "Effects of rapid prey evolution on predator-prey cycles". J Math Biol 55 (4): 541–73. doi:10.1007/s00285-007-0094-6. PMID 17483952.
10. ^ Schlegel HG, Jannasch HW (1967). "Enrichment cultures". Annu. Rev. Microbiol. 21: 49–70. doi:10.1146/annurev.mi.21.100167.000405. PMID 4860267.
11. ^ Daughton CG, Hsieh DP (1977). "Parathion utilization by bacterial symbionts in a chemostat". Appl. Environ. Microbiol. 34 (2): 175–84. PMC 242618. PMID 410368.
12. ^ Pfeiffer T, Bonhoeffer S (2004). "Evolution of cross-feeding in microbial populations". Am. Nat. 163 (6): E126–35. doi:10.1086/383593. PMID 15266392.
13. ^ G. J. Butler and G. S. K. Wolkowicz. (July 1986). "Predator-mediated competition in the chemostat" (PDF). J Math Biol. 24 (2): 67–191. doi:10.1007/BF00275997.
14. ^ Dykhuizen DE, Hartl DL (June 1983). "Selection in chemostats". Microbiol. Rev. 47 (2): 150–68. PMC 281569. PMID 6308409.
15. ^ Dykhuizen DE, Hartl DL (May 1981). "Evolution of Competitive Ability in Escherichia coli". Evolution (Evolution, Vol. 35, No. 3) 35 (3): 581–94. doi:10.2307/2408204. JSTOR 2408204.
16. ^ Bonomi A, Fredrickson AG (1976). "Protozoan feeding and bacterial wall growth". Biotechnol. Bioeng. 18 (2): 239–52. doi:10.1002/bit.260180209. PMID 1267931.
17. ^ de Crécy E, Metzgar D, Allen C, Pénicaud M, Lyons B, Hansen CJ, de Crécy-Lagard V (2007). "Development of a novel continuous culture device for experimental evolution of bacterial populations". Appl. Microbiol. Biotechnol. 77 (2): 489–96. doi:10.1007/s00253-007-1168-5. PMID 17896105.
18. ^ Zhang Z, Boccazzi P, Choi HG, Perozziello G, Sinskey AJ, Jensen KF (2006). "Microchemostat-microbial continuous culture in a polymer-based, instrumented microbioreactor". Lab Chip 6 (7): 906–13. doi:10.1039/b518396k. PMID 16804595.
19. ^ Van Hulle SW, Van Den Broeck S, Maertens J, Villez K, Schelstraete G, Volcke EI, Vanrolleghem PA (2003). "Practical experiences with start-up and operation of a continuously aerated lab-scale SHARON reactor". Commun. Agric. Appl. Biol. Sci. 68 (2 Pt A): 77–84. PMID 15296140.


text:
"Aztec Diamond" analogue for Square-Octagon graph. - MathOverflow most recent 30 from http://mathoverflow.net 2013-05-26T03:59:39Z http://mathoverflow.net/feeds/question/110169 http://www.creativecommons.org/licenses/by-nc/2.5/rdf http://mathoverflow.net/questions/110169/aztec-diamond-analogue-for-square-octagon-graph "Aztec Diamond" analogue for Square-Octagon graph. John Mangual 2012-10-20T16:56:46Z 2012-10-22T02:57:01Z
I have been reading David Speyer's Perfect Matchings and the Octahedron Recurrence, trying to carry out his "cross-wrenches" generalization of the Aztec diamond. In what follows, I'm asking for a construction of $G_{n_0,i_0,j_0}$ in the case where the infinite graph $\mathcal{G}$ gives square-octagon tiling.

I found Speyer's notation very difficult. Maybe section 4 of Perfect Matchings and Perfect Powers by Mihai Ciucu will be easier to use for this special case.
 In section 1.2 the "Aztec Diamond" theorem is stated $f(n_0, i_0, j_0) = \sum m(M)$

$f(n_0,i_0,j_0)$ is the solution to the octahedron recurrence. $$f(n,i,j)f(n-2,i,j)= f(n-1,i-1,j)f(n-1,i+1,j)-f(n-1,i,j-1)f(n-1,i,j+1)$$

The sum over matchings of generalized Aztec diamond graphs $G(n_0, i_0, j_0)$ is called $\sum m(M)$. These graphs are embeeded in an infinite grid $\mathcal{G}$.

For now, every matching is counted with unit weight: $m(M)=1$.

$n_0+i_0+j_0 \equiv 0 \mod 2$

What is the sequence of shapes corresponding to Speyer's "crosses+wrenches" construction for the square-octagon lattice? Section 3.7 some relevant info.

The faces of his lattices are indexed by pairs of integers $(i,j) \in \mathbb{Z}^2$. He defines a "level" ( I really want to avoid using his word "height", which has another meaning in terms of dominos.) $$h(i,j) = \left\{ \begin{array}{rc} 0 & \text{if }(i,j) \equiv (0,0) \mod 2\mathbb{Z}\times 2 \mathbb{Z} \\ 0 & \text{if }(i,j) \equiv (1,1) \mod 2\mathbb{Z}\times 2 \mathbb{Z} \\ 1 & \text{if }(i,j) \equiv (0,1) \mod 2\mathbb{Z}\times 2 \mathbb{Z} \\ -1 & \text{if }(i,j) \equiv (1,0) \mod 2\mathbb{Z}\times 2 \mathbb{Z}
 \end{array} \right.$$ The Octahedron recurrence has initial conditions $f(h(i,j),i,j)=1$ and specializes here to powers of 5: \begin{array}{rlc} f(2n,i,j) & = 5^{n^2} & \\ f(2n+1,i,j) & = 5^{n^2+n} & \text{if } i \equiv n \mod 2\\ f(2n+1,i,j) & = 2 \cdot 5^{n^2+n} & \text{if } j \equiv n \mod 2 \end{array} I'm not even sure this list of possibilities is exhaustive. For $(2n+1,i,j)$ only one of $i,j$ can be odd.

The shapes $G(n_0, i_0, j_0)\subset \mathcal{G}$ are planar graphs with "open" and "closed" faces. He defines the "lattice", "edges", and "faces": \begin{eqnarray} \mathcal{L} &=& \{ (n,i,j) \in \mathbb{Z}^2 : n = i + j \mod 2\} \\ \mathcal{E} &=& \{ (i,j) \in \mathbb{Z}^2: i + j \equiv 1 \mod 2\} \times \{ a,b,c,d\} \\ \mathcal{F} &=& \mathbb{Z}^2 \end{eqnarray} The faces are indexed by pairs of integers. The edges are labelled a,b,c,d.

In section 2.1 Speyer defined some cones in $\mathbb{Z}^3$: \begin{eqnarray} p_{(n_0,i_0,j_0)} &=& n_0 - |i - i_0| - |j - j_0| \\ C_{(n_0,i_0,j_0)} &=& \{ (n,i,j) \in \mathcal{L}: n \leq n_0 - |i - i_0| - |j - j_0| \} \\ \mathring{C}_{(n_0,i_0,j_0)} &=& \{ (n,i,j) \in \mathcal{L}: n < n_0 - |i - i_0| - |j - j_0| \} \\ \partial C_{(n_0,i_0,j_0)} &=& \{ (n,i,j) \in \mathcal{L}: n = n_0 - |i - i_0| - |j - j_0| \} \\ \mathcal{I} &=& \{ (i,j, n) \in \mathcal{L}: n = h(i,j) \} \\ \mathcal{U} &=& \{ (i,j, n) \in \mathcal{L}: n > h(i,j) \} \end{eqnarray}

I have been unable to sort out definition of $G_{n_0,i_0,j_0}$ in section 3.3

It would be really amazing if one could show how the dominos actually "shuffle".
 http://mathoverflow.net/questions/110169/aztec-diamond-analogue-for-square-octagon-graph/110265#110265 Answer by John Mangual for "Aztec Diamond" analogue for Square-Octagon graph. John Mangual 2012-10-21T20:09:16Z 2012-10-22T02:57:01Z
The faces are indexed by $\mathbb{Z}^2$, but $\mathring{C}_{(n_0,i_0,j_0)} \cap \mathcal{I} \in \mathbb{Z}^3$. The closed faces of $G = G_{(n_0,i_0,j_0)}$ centered at $(n_0,i_0,j_0)$ satisfy an inequality:

$$\mathring{C}_{(n_0,i_0,j_0)} \cap \mathcal{I} = \{ (i,j,n): n = h(i,j) < n_0 - |i - i_0| - |j - j_0| \}$$

How do we get a planar graph? Speyer defines a projection map that drops the last coordinate:

$$\alpha(\mathring{C}_{(n_0,i_0,j_0)} \cap \mathcal{I}) = \{ (i,j): h(i,j) + |i - i_0| + |j - j_0|< n_0 \}$$

This number $h(i,j) + |i - i_0| + |j - j_0|$ seems to be important for building the graph.
 One simple height function" is an alternating pattern of 0's and 1's. We then overlay taxicab distances from various points to get the height function. The Aztec Diamond patterns emerge

 4 010101 3 444 101010 333 44244 010101 33133 4422244 101010 3311133 442202244 010101 33133 4422244 101010 333 44244 3 444 4

Let's try this procedure for square octagon lattice.

We get a clear general sense of the shape. The Mathematica code is:

h[x_, y_] := Switch[{Mod[x, 2], Mod[y, 2]}, {0, 0}, 0, {1, 1}, 0, {1, 0}, 1, {0, 1}, -1] cut[x_, y_] = If[ x < y, x, "."] b = Table[ cut[Abs[k] + Abs[l] + h[k + 1, l], 6], {k, -6, 6}, {l, -6, 6} ]; MatrixForm[b]

It seems to be possible to take off the corners and still be an acceptable "diamond".

The analogue of "domino" shuffling in these case would be an "inductive" way of moving from one Aztec Diamond to the next. Not sure how to do this at the moment. There seems to be more than one way