text:
<img src="https://d5nxst8fruw4z.cloudfront.net/atrk.gif?account=iA1Pi1a8Dy00ym" style="display:none" height="1" width="1" alt="" />

# 3.8: Problem Solving Strategies: Use a Formula

Difficulty Level: At Grade Created by: CK-12

## Learning Objectives

• Read and understand given problem situations.
• Develop and apply the strategy: use a formula.
• Plan and compare alternative approaches to solving problems.

## Introduction

In this chapter, we have been solving problems in which quantities vary directly with one another other. In this section, we will look at few examples of ratios and percents occurring in real-world problems. We will follow the Problem Solving Plan.

Step 1 Understand the problem

Read the problem carefully. Once you have read the problem, list all the components and data that are involved. This is where you will be assigning your variables.

Step 2 Devise a plan – Translate

Come up with a way to solve the problem. Set up an equation or formula.

Step 3 Carry out the plan – Solve

This is where you solve the formula you came up with in Step 2.

Step 4 Look – Check and Interpret

Check to see if you used all your information and that the answer makes sense.

It is important that you first know what you are looking for when solving problems in mathematics. Math problems often require that you extract information and use it in a definite procedure. You must collect the appropriate information and use it (using a strategy or strategies) to solve the problem Many times, you will be writing out an equation which will enable you to find the answer.

Example 1

An architect is designing a room that is going to be twice as long as it is wide. The total square footage of the room is going to be 722 square feet. What are the dimensions in feet of the room?

Step 1 Collect Relevant Information.

Step 2 Make an Equation

Step 3 Solve

Solution

The dimensions of the room are 19 feet by 38 feet.

Is 38 twice 19?

Is 38 times 19 equal to 722?

Example 2

A passenger jet initially climbs at 2000 feet per minute after take-off from an airport at sea level. At the four minute mark this rate slows to 500 feet per minute. How many minutes pass before the jet is at 20000 feet?

Step 1

The first two pieces on information can be combined. Here is the result.

Height at four minute mark

Step 2 Write an equation.

Since we know that the height at four minutes is 8000 feet, we need to find the time taken to climb the final .

We will use to give us an equation for time.

Step 3 Solve.

Solution

The time taken to reach 20000 feet is 28 minutes.

What is 4 times 2000?

What is 24 times 500?

The total climb = initial climb + secondary climb = .

Example 3

The time taken for a moving body to travel a given distance is given by . The speed of sound in air is approximately 340 meters per second. In water, sound travels much faster at around 1500 meters per second. A small meteor hits the ocean surface 10 km away. What would be the delay in seconds between the sound heard after traveling through the air and the same sound traveling through the ocean?

Step 1 We will write out the most important information.

Step 2 We will convert this information into equations.

Time in air

Time in water

Step 3 Solve for and the delay.

Solution

The delay between the two sound waves arriving is 22.7 seconds.

Step 4 Check that the answer works.

We need to think of a different way to explain the concept.

The actual time that the sound takes in air is 29.41 seconds. In that time, it crosses the following distance.

The actual time that the sound takes in water is 6.67 seconds. In that time, it crosses the following distance of.

Both results are close to the 10000 meters that we know the sound traveled. The slight error comes from rounding our answer.

Example 4:

Deandra is looking over her paycheck. Her boss took tax from her earnings at a rate of 15%. A deduction to cover health insurance took one-twelfth of what was left. Deandra always saves one-third of what she gets paid after all the deductions. If Deandra worked 16 hours at $7.50 per hour, how much will she save this week? Step 1 Collect relevant information. Deductions: Step 2 Write an equation. Deandra’s earnings before deductions Fraction remaining after tax Fraction remaining after health Fraction to be saved Step 3 Solve Amount to save = Round to two decimal places. Solution Deandra saves$31.17.

If Deandra saves $31.17, then her take-home pay was If Deandra was paid$93.51, then before health deductions health she had

If Deandra had $102.01 after tax, then before tax she had If Deandra earned$120.01 at $7.50 per hour, then she worked for This is extremely close to the hours we know she worked (the difference comes from the fact we rounded to the nearest penny). The answer checks out. ## Lesson Summary The four steps of the Problem Solving Plan are: 1. Understand the problem 2. Devise a plan – Translate 3. Carry out the plan – Solve 4. Look – Check and Interpret ## Review Questions Use the information in the problems to create and solve an equation. 1. Patricia is building a sandbox for her daughter. It is to be five feet wide and eight feet long. She wants the height of the sand box to be four inches above the height of the sand. She has 30 cubic feet of sand. How high should the sand box be? 2. A 500 sheet stack of copy paper is 1.75 inches high. The paper tray on a commercial copy machine holds a two foot high stack of paper. Approximately how many sheets is this? 3. It was sale day in Macy’s and everything was 20% less than the regular price. Peter bought a pair of shoes, and using a coupon, got an additional 10% off the discounted price. The price he paid for the shoes was$36. How much did the shoes cost originally?
4. Peter is planning to show a video file to the school at graduation, but is worried that the distance that the audience sits from the speakers will cause the sound and the picture to be out of sync. If the audience sits 20 meters from the speakers, what is the delay between the picture and the sound? (The speed of sound in air is 340 meters per second).
5. Rosa has saved all year and wishes to spend the money she has on new clothes and a vacation. She will spend 30% more on the vacation than on clothes. If she saved $1000 in total, how much money (to the nearest whole dollar) can she spend on the vacation? 6. On a DVD, data is stored between a radius of 2.3 cm and 5.7 cm. Calculate the total area available for data storage in square cm. 7. If a Blu-ray DVD stores 25 gigabytes (GB), what is the storage density, in GB per square cm? ## Review Answers 1. 13 inches 2. Approximately 6860 sheets 3.$50
4. 0.06 seconds
5. Approximately \$565

## Texas Instruments Resources

In the CK-12 Texas Instruments Algebra I FlexBook, there are graphing calculator activities designed to supplement the objectives for some of the lessons in this chapter. See http://www.ck12.org/flexr/chapter/9613.

Show Hide Details
Description
Tags:
Subjects:
Date Created:
Feb 22, 2012
Sep 17, 2014
Reviews
Help us create better content by rating and reviewing this modality.
Image Detail
Sizes: Medium | Original

CK.MAT.ENG.SE.1.Algebra-I.3.8


text:
# Determine reactance force of four load cells arranged in two dimensions

I have constructed a "force plate" to reconstruct the location (x,y) of a steady state contact point force f. The system consists of four fixed compression load cells L1, L2, L3, and L4 and a thick aluminum plate. The aluminum plate is free to move along the z-axis only (see figure below). I have tested the system using a universal precision tester and it performs very well. Using the following equations I am able to reconstruct the location of the force based on reading from the load cells:

$$x = \frac{\sum(x_if_i)}{\sum(f_i)}$$ $$y = \frac{\sum(y_if_i)}{\sum(f_i)}$$

However I would like to create a computer model and simulation that works in the other direction. For example, solve for the force at each load cell when the magnitude of the contact force and it's location are known. It would be nice to have ideal simulated data to compare with the actual measurements taken from the precision tester.

I have spent a couple of days trying to find a solution (using sum of moments at each cell), but I have been unsuccessful. I am an electrical engineer and forces are a little beyond my comfort zone. A fellow mechanical engineer said the problem may be statically indeterminate.

Is this problem unsolvable using traditional methods? Any ideas? Thanks for reading.

EDIT

Based on Wolphram jonny solution I have attempted to solve the system of equations using the matrix method below. This method works for all points except when y = 0 ... So close!

• You exhibit a system of equations. You solve the reverse problem by inverting the system of equations. It is more compact written in matrix form, which is also the way you will find inverting linear systems of equations addressed in every introductory text on computational methods. – dmckee --- ex-moderator kitten Nov 23 '14 at 3:10
• @dmckee Thanks for the input. I have used the matrix form to solve electrical circuits but I am unsure how I can extend this to forces. I can find the inverse of the above equations but can't bridge the gap. I will look into introductory text. – atomSmasher Nov 23 '14 at 5:17

to solve the problem you need at 4 linear equations (or the two linear ones you have plus another nonlinear one). Otherwise, the solution is undetermined, you have more variables that linear equations and the number of solutions is infinite. Here are the two extra equations that you need.

1) the total force equald the applied force (otherwise it will move vertically):

$f ={\sum(f_i)}$

2) the second condition is that the plate does not tilt (zero torque), and you get (assuming it does not tilt horizontally):

$0 =\sqrt{(x-x_1)^2+(y-y_1)^2}f_1+\sqrt{(x-x_2)^2+(y-y_2)^2}f_2-\sqrt{(x-x_3)^2+(y-y_3)^2}f_3-\sqrt{(x-x_4)^2+(y-y_4)^2}f_4$

Let me know if you do not know how to solve a system of linear equations. But brute force always works (this is, isolating one variable in one equation, put it on the next, isolate the second variable, etc.

• Wolphramjonny and @dmckee I added a matrix as an edit. Does it look like I am on the right track? I ask because MATLAB is returning unrealistic values that sum to larger than total force. – atomSmasher Nov 23 '14 at 15:36
• the matrix seems fine, let me check if the is some mistake in one of my equations, or I'll try matlab to check what is going. Actally, if you already implemente din in matlab, could you send the the code? It will save me time and also might find some error on the implementation (asuming it was not mine) – Wolphram jonny Nov 23 '14 at 16:39
• I found it! You are correct, just needed a plus sign before the third term in the second equation. Thank you SO MUCH for your help! – atomSmasher Nov 23 '14 at 16:43
• Great! I am happy to hear that – Wolphram jonny Nov 23 '14 at 16:45

format: plain


text:
Guess the type of a file based on the filename using mimetypes Python module

mime_guess(file)

Arguments

file path

string


text:
# Derivatives of an odd function

1. Jul 9, 2005

### h_k331

I've come to a few assumtions that my text hasn't covered yet, and I was hoping someone could confirm these for me or let me know where I might be missing something.

Assuming f is an odd function and a > 0 and b > 0 and a < b:

If f'(x) > 0 on (a,b), then f'(x) < 0 on (-b,-a).

If f''(x) > 0 on (a,b), then f''(x) < 0 on (-b,-a).

If lim (x->a) f(x) = inf, then lim (x->-a) f(x) = -inf

If x = a is a vertical asymptote of f, then x = -a is also a vertical asymptote of f.

If lim (x->inf) f(x) = L, then lim (x->-inf) f(x) = -L

If y = L is a horizontal asymptote of f, then y = -L is also a horizontal asymptote of f.

If f is odd and f is continuous on (-a,a), then f(0) = 0

Thanks,
hk

2. Jul 9, 2005

### MalleusScientiarum

The derivative of an odd function is an even function. Anything else you want to know can be taken from that.

Also, to be "odd" requires that f(0) = 0. Figure out why.

3. Jul 10, 2005

### HallsofIvy

Staff Emeritus
No! If f(x) is odd, then f'(x) is even. f' will have the same sign (indeed exactly the same values) for both (a,b) and (-b,-a).
An easy example: if f(x)= x, then f'(x)= 1 for all x.
Yes, this is true. If f(x) is odd, then f'(x) is even and f"(x) is odd again.
Yes. Also if lim(x->)f(x)= L, then lim(x->-a)f(x)= -L.
Yes. This is essentially just a restatement of the previous statement of "If lm(x->a) f(x)= inf, then lim(x->-a)f(x)= -inf".
Yes. In fact, as above, this is true for (x-> any number) as well.
Yes. This is just a restatement of "If lim(x->inf)= L, then lim(x->-inf)(f)= -L
You don't need "and f is continuous on (-a,a)". If f is odd then f(-x)= -f(x) for all x. Taking x= 0, f(-0)= f(0)= -f(0) so 2f(0)= 0 and f(0)= 0.

4. Jul 10, 2005

### h_k331

Thank you for your reply HallsofIvy, I have a better understanding now.

hk


text:
I am currently following the course notes of CS231n: Convolutional Neural Networks for Visual Recognition in Stanford University. There are programming exercises involved, and I wanted to share my solutions to some of the problems.

The basic idea for the k-Nearest Neighbors classifier is that we find the k closest images in the dataset with respect to our query x. Here, we will perform the following processes:

Load the CIFAR-10 Dataset

CIFAR-10 is a labeled dataset that houses 80 million tiny images. It was created by Alex Krizhevsky, Vinod Nair, and Geoffrey Hinton. It contains 60,000 32x32 color images with 6,000 images per class.

We can visualize some examples in CIFAR-10, here we can see a sample of 10 classes with 7 examples each.

Figure 1: Samples of the CIFAR-10 Dataset

As we can see, for each class, there are distinct images related to it. For example, the car class is represented by different car images, some of which have different orientation or color. These images then make-up a certain “template” that can be used by the classifier in order to categorize a test image.

Compute for the L2 Distance

Distance computation is a quantifiable means of comparing two images together. To compute for distance, pixel-wise differences are often implemented. In this method, distance is computed “pixel-by-pixel” and then the elements of the corresponding matrix is added together. Highly similar images will have lower values while different images will have higher values. Moreover, images that are exactly similar have a 0 distance. The choice of distance that was used in the assignment is the L2 distance:

$d_{2}(I_{1}, I_{2}) = \sqrt{\sum_{p}(I_{1}^{p} - I_{2}^{p})^{2}}$

Thus, for images $$I_{1}$$ and $$I_{2}$$, we perform a sum of squares pixel computation for each $$p$$ and then get the square root. The assignment requires us to implement the L2 distance in three different ways.

Two-loop implementation

The two-loop computation uses a nested-loop in order to compute for the pixel-wise L2 Distance between the test and train images. This is one of the easiest methods to implement, but it takes a toll on speed because of the looping nature.

num_test = X.shape[0]
num_train = self.X_train.shape[0]
dists = np.zeros((num_test, num_train))
for i in xrange(num_test):
for j in xrange(num_train):
dists[i,j] = np.linalg.norm(self.X_train[j,:]-X[i,:])
return dists

Here, I am implementing the np.linalg.norm function to compute for the norm (which is, in a sense, equivalent to the L2 equation) of X_train and X. Furthermore, this can also be implemented by religiously following the equation above, and thus we can have something similar below:

dists[i,j] = np.sqrt(np.sum(np.square(X[i,:]-self.X_train[j,:])))

One-loop implementation

For the one-loop implementation, what we do is that in our dists matrix, we compute for the distances for each example in the test set X against the examples in the training set X_train. As we will see, instead of filling the dists matrix cell-by-cell (as we have done in the two-loop computation), we fill the dists matrix row-by-row, or in other words, by “test example by test example.”

num_test = X.shape[0]
num_train = self.X_train.shape[0]
dists = np.zeros((num_test, num_train))
for i in xrange(num_test):
dists[i, :] = np.linalg.norm(self.X_train - X[i,:], axis = 1)

This is intuitively faster than the previous implementation, because the distance computation against the training set is done in parallel. In the next implementation, we will implement a fully-vectorized computation that can further improve the speed of our computations.

No-loop implementation

The no-loop computation is a fully-vectorized implementation of the L2 distance. This eliminates the loops entirely, replacing a cell by cell (or row by row) implementation into a single matrix solution.

My workaround for this is to implement another form of the L2 Distance, which can actually be derived from the equation above. In this case, for two vectors $$\mathbf{I}_{1}$$ and $$\mathbf{I}_{2}$$. We can also compute for the L2 Distance as:

$d_{2}(\mathbf{I}_{1}, \mathbf{I}_{2}) = \left\lvert \left\lvert \mathbf{I}_{1} - \mathbf{I}_{2} \right\rvert \right\rvert = \sqrt{\left\lvert \left\lvert\mathbf{I}_{1} \right\rvert \right\rvert^{2} + \left\lvert \left\lvert \mathbf{I}_{2}\right\rvert \right\rvert^{2} - 2 \mathbf{I}_{1} \cdot \mathbf{I}_{2}}$

With this equation, we can easily compute for the dists matrix without using any loops, for this we implement the following:

num_test = X.shape[0]
num_train = self.X_train.shape[0]
dists = np.zeros((num_test, num_train))
dists = np.sqrt((X**2).sum(axis=1)[:, np.newaxis] + (self.X_train**2).sum(axis=1) - 2 * X.dot(self.X_train.T))

The vectorized version can in fact provide a very fast performance compared to the looped implementations. Using my own machine, I was able to obtain the following execution times:

Two loop version took 92.134323 seconds
One loop version took 213.639710 seconds
No loop version took 6.479004 seconds

We were then able to reduce the time it takes to compute for the L2 Distance in a large dataset from 3 minutes to just 6 seconds. Very impressive indeed!

You may notice that the one-loop implementation is much slower than the two-loop implementation, and it goes against the intuition that we had. The course instructors mentioned that the problem is system dependent and it's nothing to worry about. Source: badmephisto's answer in "Assignment#1 knn -single loop slower than double loop"

Visualize the distances

We can plot the dists matrix and visualize the distances of our test examples with respect to different training examples. Here, as you look down, we are looking at a representation of our test examples. As you look from left to right, we see the training examples. Thus we have over 500 test examples and over 5000 training examples. Darker regions represent areas of low distance (more similar images) while lighter regions represent areas of high distance (more different images).

Figure 2: Visualization of the dists matrix

The distinctly visible rows (say, the dark rows in the 300 mark or the white rows in the 400 mark) represent test examples that are similar (or different) to most of the training examples. Let’s focus on the dark rows in the 300 mark. The reason why distinct dark rows can be seen in it is because there could be many classes in the training set that was found to be similar to it. This can be attributed to similar backgrounds or hues that can confuse our classifier into thinking that it belongs to the same class.

On the other hand, the columns we see are in fact training examples that are not similar to any of the test examples. Perhaps a certain training example was found to have no any significant similarity to any of the test examples. This will then result to a high L2 distance, and consequently, generate a white column into our visualization.

Perform cross-validation to find the best k

One good method to know the best value of k, or the best number of neighbors that will do the “majority vote” to identify the class is through cross-validation. What we will do here is to split the training set into 5 folds, and compute the accuracies with respect to an array of k choices. From this we sort the accuracies and obtain the best value of k.

Firt we split the training set X_train:

num_folds = 5
k_choices = [1, 3, 5, 8, 10, 12, 15, 20, 50, 100]

X_train_folds = []
y_train_folds = []

X_train_folds = np.array_split(X_train, num_folds)
y_train_folds = np.array_split(y_train, num_folds)

And then we perform cross-validation. Thus, for each k value, we will run the k-NN algorithm num_folds times. Here we will use all but one folds as our training data, and the last one as our validation set. We then store the accuracies of each fold and all values of k in the k_to_accuracies dictionary.

for k in k_choices:
k_to_accuracies[k] = []

for k in k_choices:
print('k=%d' % k)
for j in range(num_folds):
# Use all but one folds as our crossval training set
X_train_crossval = np.vstack(X_train_folds[0:j] + X_train_folds[j+1:])
# Use the last fold as our crossval test set
X_test_crossval = X_train_folds[j]

y_train_crossval = np.hstack(y_train_folds[0:j]+y_train_folds[j+1:])
y_test_crossval = y_train_folds[j]

# Train the k-NN Classifier using the crossval training set
classifier.train(X_train_crossval, y_train_crossval)

# Use the trained classifer to compute the distance of our crossval test set
dists_crossval = classifier.compute_distances_no_loops(X_test_crossval)

y_test_pred = classifier.predict_labels(dists_crossval, k)
num_correct = np.sum(y_test_pred == y_test_crossval)
accuracy = float(num_correct) / num_test

k_to_accuracies[k].append(accuracy)

In order to see how the value of k changes with respect to our cross validation set, we can visualize them in terms of line plot with error bars:

Figure 3: Visualization of the cross-validation procedure with different k values

From now, we can choose a good k value. Let’s take k = 10.

Got 141 / 500 correct => accuracy: 0.282000

And thus we were able to obtain an accuracy of 28.2%. It is not as good as state-of-the-art classifiers today (a Convolutional Neural Network solution in Kaggle was able to reach a whopping 95%). But this is a good start to learn the image classification pipeline and the efficiency of the vectorization method.

Changelog

• 12-16-2018: Update cross-validation plot, thanks @earnshae for spotting the error!


text:
# Defensive programming type-checking

I have issues with dynamically typed languages, and I tend to worry about type a lot.

Numpy has different behaviour depending on if something is a matrix or a plain ndarray, or a list. I didn't originally have all these asserts, but I inserted them while trying to debug a type error.

from numpy import *
sigmoid = vectorize(lambda(x): 1.0/(1.0+exp(-x)))

def prob_hOn_givenV (v,b,w):
assert isinstance(v,matrix)
assert isinstance(w,matrix)
assert isinstance(b,matrix)
assert shape(v)[1]==shape(w)[0]
#print("|v|="+str(shape(v)) +"|w|="+str(shape(w)) )
return sigmoid(b+v*w) #sum up rows (v is a column vector)

def prob_vOn_givenH (h,a,w):
assert isinstance(h,matrix)
assert isinstance(a,matrix)
assert isinstance(w,matrix)

assert shape(h)[1]==shape(w.T)[0]

return sigmoid(a+h*w.T) #sum up columns. (h is a row vector)

Is there a better way? Perhaps a defensive programming toolkit? There is also duplication in the code, but I can't see a nice way of removing it while maintaining meaning. People familiar with Restricted Boltzman Machines will recognise the conditional formula used for Gibbs sampling for contrastive divergence.

• The key point is that a compiler's static type checking is a kind of test, but an incomplete one (otherwise statically typed languages would have no bugs). In a dynamically typed languages, unit tests take the place of the compiler's type checks, and add some degree of assurance that the code is correct (something the compiler can never do for you, whether statically or dynamically typed). – Wayne Conrad Jan 13 '14 at 14:23
• Aside: from numpy import * -- don't do this. This will replace some common Python builtins, like any and all, with numpy versions which can silently return exactly the opposite values. – DSM Jan 13 '14 at 15:48

First, I recommend avoiding the matrix type altogether. The problems it causes outweighs the minor syntactical convenience it provides, in my (and quite a few others') opinion.

Second, the idiomatic way to do this kind of thing in numpy is not to assert that the inputs are particular types, but to coerce them to an ndarray. np.asarray() does this efficiently; if the input is an ndarray, the input passes through untouched; if it is an ndarray subclass, then a new ndarray will be created but only as a view on the original data so no data will be copied.

import numpy as np

def sigmoid(x):
# No need to use vectorize() for this. It's already vectorized.
return 1.0 / (1.0 + np.exp(-x))

def prob_hOn_givenV(v, b, w):
v = np.asarray(v)
b = np.asarray(b)
w = np.asarray(w)
# Don't bother checking the shape. np.dot() will do that for us.
# Strictly speaking, the asarray(v) and asarray(w) aren't necessary
# since np.dot(v, w) already does that internally. But it does no harm.
return sigmoid(b + np.dot(v, w))

• my issue wit ndarray was that it isn't nice for checking shape. Because ndarray doesn't differentiate between shape of (1,N),(N,1) and (N). and that gives me headaches trying to ensure I have the formula right (esp when w is square) – Lyndon White Jan 13 '14 at 14:15

These are the best links to pythonic ways of doing various checks:

You can use particular sets of asserts (or any other piece of code for more complicated checks, for example checking if an list of ints truly contains all ints) as a function, and then use that function as a parameter to the decorator, making a very clean description of what you're checking.

The accept/returns decorator is a quick and clean way of checking your inputs. The pre- and post-condition checking decorator is more suited for larger or more complicated sets of checks, whether it's type enforcement, or parameter range, or any other relationship between the data, like if an array's elements are sorted.

I used to include all these checks in the function alone, but with some functions it makes the code rather unreadable, as the real functionality gets lost in all the checks. This is a fairly simple way to organize your checks, and make your code easier to read.

+1 for not trusting duck typing ;)


text:
MathsGee is free of annoying ads. We want to keep it like this. You can help with your DONATION

0 like 0 dislike
27 views
I am stuck, how do i simplify $\frac{2^{n+4} - 6\times 2^{n+1}}{2^{n+2} \times 5}$
| 27 views


text:
# How can I know the type of filter from its cutoff frequency?

So I have the following equation $$y[n]=0.9y[n-1]+0.1x[n]$$

We can find easily find the transfer function, which is

$$H(z)=\frac{0.1}{1-0.9z^{-1}}$$

and from that, the frequency response, which is

$$H(e^{j \omega})=\frac{0.1}{1-0.9 e^{-j \omega}}$$

To find the cutoff frequency we just make the magnitude of the above equal to $\frac{1}{\sqrt{2}}$. Then, $\omega_0 = 0.0675\Rightarrow f_0 = 0.0107$.

Okay, so how can we say that given $f_0 = f_c$ the filter is a LPF or HPF?

• Does the frequency response increase or decrease as the frequency increases? – MBaz Nov 17 '17 at 2:30

Types of filters, such as LPF, HPF, BPF or BSF, are not described by their cutoff frequencies $f_c$ but through their passband or stopband frequency $\omega$ region.

For example, in your case of the filter $H(z) = 1 / (1 - 0.9 z^{-1})$, the passband is in the low frequencies (where the magnitude of the frequency response $H(e^{j\omega})$ is greater than $1/\sqrt{2}$. And by your definition that region corresponds to $\omega \in (-f_c , f_c)$ which indicates a lowpass range of frequencies.

Other filters like HPF and BPF follow in a similar manner. Note that specific filters such as comb or notch types are defined in a different style than this.

It's actually the Z Transform

$$H(z) = \frac{0.1}{1-0.9z^{-1}}$$

Now get the frequency response by evaluating $$H(e^{j\omega}) = \frac{0.1}{1-0.9z^{-1}} \Bigr|_{z = e^{j\omega}}$$

You can now plot magnitude and phase for a given frequency $\omega$

• you're correct mitch. i have enough rep that i can edit his question. the only thing i need to do to fix yours (which is not the same as completing it) is to change $w$ to $\omega$. – robert bristow-johnson Nov 17 '17 at 4:55


text:
# Detour Monophonic Graphoidal Covering Number of Corona Product Graph of Some Standard Graphs with the Wheel

Authors

1 Assistant Professor Department of Mathematics University College of Engineering Nagercoil Anna University, Tirunelveli Region Tamil Nadu, India.

2 Anna University, Tirunelveli Region Nagercoil - 629 004, India.

Abstract

A chord of a path $P$ is an edge joining two non-adjacent vertices of $P$. A path  $P$ is called a monophonic path if it is a chordless path. A longest $x-y$ monophonic path is called an $x-y$ detour monophonic path. A  detour monophonic graphoidal cover of a graph $G$ is a collection $\psi_{dm}$ of detour monophonic paths in $G$ such that every vertex of $G$ is an internal vertex  of at most one  detour monophonic path in $\psi_{dm}$ and every edge of $G$ is in exactly one  detour monophonic path in $\psi_{dm}$. The minimum cardinality of a  detour monophonic graphoidal cover of $G$ is called the  detour monophonic graphoidal covering number of $G$ and is denoted by $\eta_{dm}(G)$. In this paper, we find the  detour monophonic graphoidal covering number of corona product of wheel with some standard graphs

Keywords


text:
# Why non gaussian variables are independent

I have read a lot about ICA. I think I could not find the answer that why non-Gaussian Variables are independent. What I understand, Central Limit Theorem states that

distribution of sum of independent variable tends toward more Gaussian than its original random variables.

$s_i$ are the number of original independent sources in ICA; whereas ICA model is $x=As$. So we can define $y=w^Ts$. The main goal is to find the unmixing matrix $w$ that maximize the non-Gausaanity. So my question is what is non-Gaussanity here and why its necessary to maximize it to extract the original sources.

• Welcome to DSP.SE! Any random variable can be independent from any other one. It does not depend on whether they are Gaussian distributed or non-Gaussian distributed. Why do you think they should be? – Peter K. Oct 29 '15 at 8:58
• Well, Thats the confusion, how non-gaussian variables are independent. Central Limit Theorem Says that distribution of sum of independent variable tends toward more Gaussian than its original random variables. Also maximizing non-Gaussanity yields one of independent component. So What is the connection of non-Gaussanity with independence of components? I think non-gaussanity gives local maxima for that particular component and based on local maxima we can tell all uncorrelated components – M Ali Qadar Oct 29 '15 at 10:55

The model ICA uses says that there exist some unknown, statistically independent sources, $s_i$ that are non-normally distributed (their distributions are something other than Gaussian):

$$s_i \sim S(\mu_{s_i}, \sigma^2_{s_i})$$

where $S$ is some (possibly) known but non-Gaussian distribution with mean $\mu_{s_i}$ and variance $\sigma^2_{s_i}$.

Then it is assumed that what you can actually measure is the addition of these: $$\mathbf{x} = \mathbf{A}\mathbf{s}$$ where $\mathbf{s}$ is the vector of the $s_i, i=1,\ldots,N$, $\mathbf{A}$ is an $N\times N$ matrix (usually assumed to be invertible) and $\mathbf{x}$ is the vector of the actual measurements.

Because the $x_i$ will just be weighted sums of the $s_i$: $$x_i = a_{i1} s_1 + a_{i2} s_2 + \cdots + a_{iN} s_N$$ the central limit theorem says that the distribution of $x_i$ will be closer to Gaussian than the distribution of the $s_i$ (provided certain non-restrictive conditions on the true distribution of the $s_i$ are met).

Then all ICA really tries to do is to find a $\mathbf{W} = \mathbf{A}^{-1}$ the inverse of $\mathbf{A}$.

There are any number of measures for "non-Gaussianity". One of the simplest (?) is to use kurtosis as the measure of how far the sample of a random variable is from Gaussianity.

So my question is what is non-Gaussianity here and why its necessary to maximize it to extract the original sources.

There are several different ways one could measure non-Gaussianity. For example, kurtosis can be used as it is known that the kurtosis of a Gaussian is 3. Any distribution with a kurtosis different from 3 is therefore "non-Gaussian" to some extent.

The reason we want non-Gaussianity is because we assumed that the original sources are non-Gaussian.

• Concise and enlightening as OP requested. – Anton Antonov May 22 '16 at 14:08

In the explanation above, the last statement is not the actual reason why in ICA you assume non-Gaussian sources. After all, you could as well assume Gaussian sources and after the mixing process, the observed data will look Gaussian, which is not a problem at all.

The reason for assuming non-Gaussian sources was pointed out by Comon (1994), and it is because in order to learn a unique factorization $\mathbf{x=As}$, at most one component of s can be Gaussian. Which it has to do with the invariance under rotation of the Gaussian distribution. For simplicity, we usually assume non-Gaussian priors, where for instance $p_i(s_{i})\propto \dfrac{1}{\cosh s_{i}}$ yields the non-linear contrast function, $\tanh$, used in the ICA algorithm.

In another note related to the title of the post, "Why non-Gaussian variables are independent". Independence and non-Gaussianity are two different issues. Informally, independence means that a joint distribution has a factorial form on its components such that $p(s_1,\ldots,s_n)=\prod_i^n p_i(s_i)$, where the distributions $p_i(s_i)$ may or may not be Gaussian.


text:
• •

### 多元多项式矩阵等价的进一步结果

1. 湖南科技大学数学与计算科学学院, 湘潭 411201
• 收稿日期:2021-07-24 修回日期:2021-10-23 出版日期:2021-12-25 发布日期:2022-03-16
• 基金资助:
国家自然科学基金（11871207）资助课题.

LI Dongmei, GUI Yingying. Further Results on the Equivalence of Multivariate Polynomial Matrices[J]. Journal of Systems Science and Mathematical Sciences, 2021, 41(12): 3299-3310.

### Further Results on the Equivalence of Multivariate Polynomial Matrices

LI Dongmei, GUI Yingying

1. School of Mathematics and Computing Sciences, Hunan University of Science and Technology, Xiangtan 411201
• Received:2021-07-24 Revised:2021-10-23 Online:2021-12-25 Published:2022-03-16

Multidimensional systems are often described by polynomial matrices, and problems on the equivalence of multidimensional systems in system theory are often transformed into problems on the equivalence of polynomial matrices. In this paper, we mainly study the equivalence of two kinds of multivariate polynomial matrices, and obtain the discriminant conditions for the equivalence of these matrices and their Smith forms, respectively. The conditions are easily verified, and an example is also used to illustrate these in the paper.

MR(2010)主题分类:

()
 [1] Bose N. Applied Multidimensional Systems Theory. New Work:Van Nostrand Reinhold, 1982.[2] Bose N, Buchberger B, Guiver J. Multidimensional Systems Theory and Applications. Dordrecht, The Netherlands:Kluwer, 2003.[3] Rosenbrock H. State Space and Multivariate Theory. London, New York:Nelson-Wiley, 1970.[4] Frost M, Boudellioua B. Some further results concerning matrices with elements in a polynomial ring. Int. J. Control, 1986, 43(5):1543-1555.[5] Frost M, Storey C. Euivalence of a matrix over R[s, z] with its Smith form. Int. J. Control, 1979, 28(5):665-671.[6] Fronasini E. nD polynimial matrices with applications to multimensional signal analysis. Multidimensional Systems and Signal Processing, 1997, 8:387-408.[7] Liu J, Wang M. New results on multivariate polynomial matrix factorizations. Linear Algebra and Its Applicationgs, 2013, 438:87-95.[8] Lin Z, Boudellioua M, Xu L. On the equivalence and factorization of multivariate polynomial matrices. Proceeding of the IEEE, 2006, 4911-4914.[9] Lin Z. On matrix faction descriptions of multivariable linear n-D systems. IEEE Trans. Circuits Syst. I, 2007, 54:1298-1405.[10] Liu J, Li D, Zheng L. The Lin-Bose problem. IEEE Trans. Circuits Syst. II, 2014, 61:41-43.[11] Li D, Liu J, Zheng L. On the equivalence of multivariate polynomial matrix. Multidim Syst. Sign Process, 2017, 28:225-235.[12] Lu D, Wang D, Xiao F. Further results on the factorization and equivalence for multivariate polynomial matrices. Proceedings of ISSAC, 2020, 328-335.[13] Li D, Liang R. Serre's reduction and the Smith forms of multivariate polynomial matrices. Mathematical Problems in Engineering, 2020, 50-66.[14] Li D, Liu J, Zheng L. On Serre reduction of multidimensional systems. Mathematical Problems in Engineering, 2020, 1-13.[15] Li D, Liu J, Chu D. The Smith form of a multivariate polynomial matrix over an arbitrary coefficient field. Linear and Multilinear Algebra, 2020, 1-14.
 [1] 李冬梅，粱芮，刘金旺. 二元多项式矩阵Smith型的进一步结果[J]. 系统科学与数学, 2019, 39(12): 1983-1997. [2] 刘金旺，陈彬，陈小松. n元多项式矩阵有MLP分解的新判别算法[J]. 系统科学与数学, 2012, 32(8): 957-963. [3] 刘金旺;陈斌. Lin-Bose问题的进一步研究[J]. 系统科学与数学, 2010, 30(11): 1535-1539. [4] 王明生. 多变量多项式矩阵素分解的结果和问题[J]. 系统科学与数学, 2009, 29(9): 1249-1255. [5] 许可康;高志强. 多项式矩阵方程及线性控制系统[J]. 系统科学与数学, 2000, 20(3): 280-284.


text:
# Problem: Convert 85.00 oF to K.

###### FREE Expert Solution

Recall that the conversion from Celsius to Fahrenheit and Celsius to Kelvin is given by:

$\overline{){\mathbf{°}}{\mathbf{F}}{\mathbf{=}}{\mathbf{1}}{\mathbf{.}}{\mathbf{8}}{\mathbf{\left(}}{\mathbf{°}}{\mathbf{C}}{\mathbf{\right)}}{\mathbf{+}}{\mathbf{32}}}$

Converting 0 K to °F

###### Problem Details

Convert 85.00 oF to K.

Frequently Asked Questions

What scientific concept do you need to know in order to solve this problem?

Our tutors have indicated that to solve this problem you will need to apply the Energy, Heat and Temperature concept. You can view video lessons to learn Energy, Heat and Temperature. Or if you need more Energy, Heat and Temperature practice, you can also practice Energy, Heat and Temperature practice problems.


text:
gi-gtk-3.0.24: Gtk bindings

Copyright Will Thompson Iñaki García Etxebarria and Jonas Platte LGPL-2.1 Iñaki García Etxebarria (garetxe@gmail.com) None Haskell2010

GI.Gtk.Objects.Clipboard

Description

The Clipboard object represents a clipboard of data shared between different processes or between different widgets in the same process. Each clipboard is identified by a name encoded as a Atom. (Conversion to and from strings can be done with atomIntern and atomName.) The default clipboard corresponds to the “CLIPBOARD” atom; another commonly used clipboard is the “PRIMARY” clipboard, which, in X, traditionally contains the currently selected text.

To support having a number of different formats on the clipboard at the same time, the clipboard mechanism allows providing callbacks instead of the actual data. When you set the contents of the clipboard, you can either supply the data directly (via functions like clipboardSetText), or you can supply a callback to be called at a later time when the data is needed (via gtk_clipboard_set_with_data() or gtk_clipboard_set_with_owner().) Providing a callback also avoids having to make copies of the data when it is not needed.

gtk_clipboard_set_with_data() and gtk_clipboard_set_with_owner() are quite similar; the choice between the two depends mostly on which is more convenient in a particular situation. The former is most useful when you want to have a blob of data with callbacks to convert it into the various data types that you advertise. When the clearFunc you provided is called, you simply free the data blob. The latter is more useful when the contents of clipboard reflect the internal state of a Object (As an example, for the PRIMARY clipboard, when an entry widget provides the clipboard’s contents the contents are simply the text within the selected region.) If the contents change, the entry widget can call gtk_clipboard_set_with_owner() to update the timestamp for clipboard ownership, without having to worry about clearFunc being called.

Requesting the data from the clipboard is essentially asynchronous. If the contents of the clipboard are provided within the same process, then a direct function call will be made to retrieve the data, but if they are provided by another process, then the data needs to be retrieved from the other process, which may take some time. To avoid blocking the user interface, the call to request the selection, clipboardRequestContents takes a callback that will be called when the contents are received (or when the request fails.) If you don’t want to deal with providing a separate callback, you can also use clipboardWaitForContents. What this does is run the GLib main loop recursively waiting for the contents. This can simplify the code flow, but you still have to be aware that other callbacks in your program can be called while this recursive mainloop is running.

Along with the functions to get the clipboard contents as an arbitrary data chunk, there are also functions to retrieve it as text, clipboardRequestText and clipboardWaitForText. These functions take care of determining which formats are advertised by the clipboard provider, asking for the clipboard in the best available format and converting the results into the UTF-8 encoding. (The standard form for representing strings in GTK+.)

Synopsis

# Exported types

newtype Clipboard Source #

Memory-managed wrapper type.

Constructors

 Clipboard (ManagedPtr Clipboard)
Instances
 Source # Instance detailsDefined in GI.Gtk.Objects.Clipboard Methods Source # Instance detailsDefined in GI.Gtk.Objects.Clipboard Source # Instance detailsDefined in GI.Gtk.Objects.Clipboard

class GObject o => IsClipboard o Source #

Type class for types which can be safely cast to Clipboard, for instance with toClipboard.

Instances
 (GObject a, (UnknownAncestorError Clipboard a :: Constraint)) => IsClipboard a Source # Instance detailsDefined in GI.Gtk.Objects.Clipboard Source # Instance detailsDefined in GI.Gtk.Objects.Clipboard

toClipboard :: (MonadIO m, IsClipboard o) => o -> m Clipboard Source #

Cast to Clipboard, for types for which this is known to be safe. For general casts, use castTo.

A convenience alias for Nothing :: Maybe Clipboard.

# Methods

## clear

Arguments

 :: (HasCallStack, MonadIO m, IsClipboard a) => a clipboard: a Clipboard -> m ()

Clears the contents of the clipboard. Generally this should only be called between the time you call gtk_clipboard_set_with_owner() or gtk_clipboard_set_with_data(), and when the clearFunc you supplied is called. Otherwise, the clipboard may be owned by someone else.

## get

Arguments

 :: (HasCallStack, MonadIO m) => Atom selection: a Atom which identifies the clipboard to use -> m Clipboard Returns: the appropriate clipboard object. If no clipboard already exists, a new one will be created. Once a clipboard object has been created, it is persistent and, since it is owned by GTK+, must not be freed or unreffed.

Returns the clipboard object for the given selection. See clipboardGetForDisplay for complete details.

## getDefault

Arguments

 :: (HasCallStack, MonadIO m, IsDisplay a) => a display: the Display for which the clipboard is to be retrieved. -> m Clipboard Returns: the default clipboard object.

Returns the default clipboard object for use with cut/copy/paste menu items and keyboard shortcuts.

Since: 3.16

## getDisplay

Arguments

 :: (HasCallStack, MonadIO m, IsClipboard a) => a clipboard: a Clipboard -> m Display Returns: the Display associated with clipboard

Gets the Display associated with clipboard

Since: 2.2

## getForDisplay

Arguments

 :: (HasCallStack, MonadIO m, IsDisplay a) => a display: the Display for which the clipboard is to be retrieved or created. -> Atom selection: a Atom which identifies the clipboard to use. -> m Clipboard Returns: the appropriate clipboard object. If no clipboard already exists, a new one will be created. Once a clipboard object has been created, it is persistent and, since it is owned by GTK+, must not be freed or unrefd.

Returns the clipboard object for the given selection. Cut/copy/paste menu items and keyboard shortcuts should use the default clipboard, returned by passing GDK_SELECTION_CLIPBOARD for selection. (GDK_NONE is supported as a synonym for GDK_SELECTION_CLIPBOARD for backwards compatibility reasons.) The currently-selected object or text should be provided on the clipboard identified by GDK_SELECTION_PRIMARY. Cut/copy/paste menu items conceptually copy the contents of the GDK_SELECTION_PRIMARY clipboard to the default clipboard, i.e. they copy the selection to what the user sees as the clipboard.

(Passing GDK_NONE is the same as using gdk_atom_intern ("CLIPBOARD", FALSE).

See the FreeDesktop Clipboard Specification for a detailed discussion of the “CLIPBOARD” vs. “PRIMARY” selections under the X window system. On Win32 the GDK_SELECTION_PRIMARY clipboard is essentially ignored.)

It’s possible to have arbitrary named clipboards; if you do invent new clipboards, you should prefix the selection name with an underscore (because the ICCCM requires that nonstandard atoms are underscore-prefixed), and namespace it as well. For example, if your application called “Foo” has a special-purpose clipboard, you might call it “_FOO_SPECIAL_CLIPBOARD”.

Since: 2.2

## getOwner

Arguments

 :: (HasCallStack, MonadIO m, IsClipboard a) => a clipboard: a Clipboard -> m (Maybe Object) Returns: the owner of the clipboard, if any; otherwise Nothing.

If the clipboard contents callbacks were set with gtk_clipboard_set_with_owner(), and the gtk_clipboard_set_with_data() or clipboardClear has not subsequently called, returns the owner set by gtk_clipboard_set_with_owner().

## requestContents

Arguments

 :: (HasCallStack, MonadIO m, IsClipboard a) => a clipboard: a Clipboard -> Atom target: an atom representing the form into which the clipboard owner should convert the selection. -> ClipboardReceivedFunc callback: A function to call when the results are received (or the retrieval fails). If the retrieval fails the length field of selectionData will be negative. -> m ()

Requests the contents of clipboard as the given target. When the results of the result are later received the supplied callback will be called.

## requestImage

Arguments

 :: (HasCallStack, MonadIO m, IsClipboard a) => a clipboard: a Clipboard -> ClipboardImageReceivedFunc callback: a function to call when the image is received, or the retrieval fails. (It will always be called one way or the other.) -> m ()

Requests the contents of the clipboard as image. When the image is later received, it will be converted to a Pixbuf, and callback will be called.

The pixbuf parameter to callback will contain the resulting Pixbuf if the request succeeded, or Nothing if it failed. This could happen for various reasons, in particular if the clipboard was empty or if the contents of the clipboard could not be converted into an image.

Since: 2.6

## requestRichText

Arguments

 :: (HasCallStack, MonadIO m, IsClipboard a, IsTextBuffer b) => a clipboard: a Clipboard -> b buffer: a TextBuffer -> ClipboardRichTextReceivedFunc callback: a function to call when the text is received, or the retrieval fails. (It will always be called one way or the other.) -> m ()

Requests the contents of the clipboard as rich text. When the rich text is later received, callback will be called.

The text parameter to callback will contain the resulting rich text if the request succeeded, or Nothing if it failed. The length parameter will contain text’s length. This function can fail for various reasons, in particular if the clipboard was empty or if the contents of the clipboard could not be converted into rich text form.

Since: 2.10

## requestTargets

Arguments

 :: (HasCallStack, MonadIO m, IsClipboard a) => a clipboard: a Clipboard -> ClipboardTargetsReceivedFunc callback: a function to call when the targets are received, or the retrieval fails. (It will always be called one way or the other.) -> m ()

Requests the contents of the clipboard as list of supported targets. When the list is later received, callback will be called.

The targets parameter to callback will contain the resulting targets if the request succeeded, or Nothing if it failed.

Since: 2.4

## requestText

Arguments

 :: (HasCallStack, MonadIO m, IsClipboard a) => a clipboard: a Clipboard -> ClipboardTextReceivedFunc callback: a function to call when the text is received, or the retrieval fails. (It will always be called one way or the other.) -> m ()

Requests the contents of the clipboard as text. When the text is later received, it will be converted to UTF-8 if necessary, and callback will be called.

The text parameter to callback will contain the resulting text if the request succeeded, or Nothing if it failed. This could happen for various reasons, in particular if the clipboard was empty or if the contents of the clipboard could not be converted into text form.

## requestUris

Arguments

 :: (HasCallStack, MonadIO m, IsClipboard a) => a clipboard: a Clipboard -> ClipboardURIReceivedFunc callback: a function to call when the URIs are received, or the retrieval fails. (It will always be called one way or the other.) -> m ()

Requests the contents of the clipboard as URIs. When the URIs are later received callback will be called.

The uris parameter to callback will contain the resulting array of URIs if the request succeeded, or Nothing if it failed. This could happen for various reasons, in particular if the clipboard was empty or if the contents of the clipboard could not be converted into URI form.

Since: 2.14

## setCanStore

Arguments

 :: (HasCallStack, MonadIO m, IsClipboard a) => a clipboard: a Clipboard -> Maybe [TargetEntry] targets: array containing information about which forms should be stored or Nothing to indicate that all forms should be stored. -> m ()

Hints that the clipboard data should be stored somewhere when the application exits or when gtk_clipboard_store () is called.

This value is reset when the clipboard owner changes. Where the clipboard data is stored is platform dependent, see gdk_display_store_clipboard () for more information.

Since: 2.6

## setImage

Arguments

 :: (HasCallStack, MonadIO m, IsClipboard a, IsPixbuf b) => a clipboard: a Clipboard object -> b pixbuf: a Pixbuf -> m ()

Sets the contents of the clipboard to the given Pixbuf. GTK+ will take responsibility for responding for requests for the image, and for converting the image into the requested format.

Since: 2.6

## setText

Arguments

 :: (HasCallStack, MonadIO m, IsClipboard a) => a clipboard: a Clipboard object -> Text text: a UTF-8 string. -> Int32 len: length of text, in bytes, or -1, in which case the length will be determined with strlen(). -> m ()

Sets the contents of the clipboard to the given UTF-8 string. GTK+ will make a copy of the text and take responsibility for responding for requests for the text, and for converting the text into the requested format.

## store

Arguments

 :: (HasCallStack, MonadIO m, IsClipboard a) => a clipboard: a Clipboard -> m ()

Stores the current clipboard data somewhere so that it will stay around after the application has quit.

Since: 2.6

## waitForContents

Arguments

 :: (HasCallStack, MonadIO m, IsClipboard a) => a clipboard: a Clipboard -> Atom target: an atom representing the form into which the clipboard owner should convert the selection. -> m (Maybe SelectionData) Returns: a newly-allocated SelectionData object or Nothing if retrieving the given target failed. If non-Nothing, this value must be freed with selectionDataFree when you are finished with it.

Requests the contents of the clipboard using the given target. This function waits for the data to be received using the main loop, so events, timeouts, etc, may be dispatched during the wait.

## waitForImage

Arguments

 :: (HasCallStack, MonadIO m, IsClipboard a) => a clipboard: a Clipboard -> m (Maybe Pixbuf) Returns: a newly-allocated Pixbuf object which must be disposed with objectUnref, or Nothing if retrieving the selection data failed. (This could happen for various reasons, in particular if the clipboard was empty or if the contents of the clipboard could not be converted into an image.)

Requests the contents of the clipboard as image and converts the result to a Pixbuf. This function waits for the data to be received using the main loop, so events, timeouts, etc, may be dispatched during the wait.

Since: 2.6

## waitForTargets

Arguments

 :: (HasCallStack, MonadIO m, IsClipboard a) => a clipboard: a Clipboard -> m (Bool, [Atom]) Returns: True if any targets are present on the clipboard, otherwise False.

Returns a list of targets that are present on the clipboard, or Nothing if there aren’t any targets available. The returned list must be freed with free. This function waits for the data to be received using the main loop, so events, timeouts, etc, may be dispatched during the wait.

Since: 2.4

## waitForText

Arguments

 :: (HasCallStack, MonadIO m, IsClipboard a) => a clipboard: a Clipboard -> m (Maybe Text) Returns: a newly-allocated UTF-8 string which must be freed with free, or Nothing if retrieving the selection data failed. (This could happen for various reasons, in particular if the clipboard was empty or if the contents of the clipboard could not be converted into text form.)

Requests the contents of the clipboard as text and converts the result to UTF-8 if necessary. This function waits for the data to be received using the main loop, so events, timeouts, etc, may be dispatched during the wait.

## waitForUris

Arguments

 :: (HasCallStack, MonadIO m, IsClipboard a) => a clipboard: a Clipboard -> m (Maybe [Text]) Returns: a newly-allocated Nothing-terminated array of strings which must be freed with strfreev, or Nothing if retrieving the selection data failed. (This could happen for various reasons, in particular if the clipboard was empty or if the contents of the clipboard could not be converted into URI form.)

Requests the contents of the clipboard as URIs. This function waits for the data to be received using the main loop, so events, timeouts, etc, may be dispatched during the wait.

Since: 2.14

## waitIsImageAvailable

Arguments

 :: (HasCallStack, MonadIO m, IsClipboard a) => a clipboard: a Clipboard -> m Bool Returns: True is there is an image available, False otherwise.

Test to see if there is an image available to be pasted This is done by requesting the TARGETS atom and checking if it contains any of the supported image targets. This function waits for the data to be received using the main loop, so events, timeouts, etc, may be dispatched during the wait.

This function is a little faster than calling clipboardWaitForImage since it doesn’t need to retrieve the actual image data.

Since: 2.6

## waitIsRichTextAvailable

Arguments

 :: (HasCallStack, MonadIO m, IsClipboard a, IsTextBuffer b) => a clipboard: a Clipboard -> b buffer: a TextBuffer -> m Bool Returns: True is there is rich text available, False otherwise.

Test to see if there is rich text available to be pasted This is done by requesting the TARGETS atom and checking if it contains any of the supported rich text targets. This function waits for the data to be received using the main loop, so events, timeouts, etc, may be dispatched during the wait.

This function is a little faster than calling clipboardWaitForRichText since it doesn’t need to retrieve the actual text.

Since: 2.10

## waitIsTargetAvailable

Arguments

 :: (HasCallStack, MonadIO m, IsClipboard a) => a clipboard: a Clipboard -> Atom target: A Atom indicating which target to look for. -> m Bool Returns: True if the target is available, False otherwise.

Checks if a clipboard supports pasting data of a given type. This function can be used to determine if a “Paste” menu item should be insensitive or not.

If you want to see if there’s text available on the clipboard, use gtk_clipboard_wait_is_text_available () instead.

Since: 2.6

## waitIsTextAvailable

Arguments

 :: (HasCallStack, MonadIO m, IsClipboard a) => a clipboard: a Clipboard -> m Bool Returns: True is there is text available, False otherwise.

Test to see if there is text available to be pasted This is done by requesting the TARGETS atom and checking if it contains any of the supported text targets. This function waits for the data to be received using the main loop, so events, timeouts, etc, may be dispatched during the wait.

This function is a little faster than calling clipboardWaitForText since it doesn’t need to retrieve the actual text.

## waitIsUrisAvailable

Arguments

 :: (HasCallStack, MonadIO m, IsClipboard a) => a clipboard: a Clipboard -> m Bool Returns: True is there is an URI list available, False otherwise.

Test to see if there is a list of URIs available to be pasted This is done by requesting the TARGETS atom and checking if it contains the URI targets. This function waits for the data to be received using the main loop, so events, timeouts, etc, may be dispatched during the wait.

This function is a little faster than calling clipboardWaitForUris since it doesn’t need to retrieve the actual URI data.

Since: 2.14

# Signals

## ownerChange

type C_ClipboardOwnerChangeCallback = Ptr () -> Ptr EventOwnerChange -> Ptr () -> IO () Source #

Type for the callback on the (unwrapped) C side.

Arguments

 = EventOwnerChange event: the gdkEventOwnerChange event -> IO ()

The ::owner-change signal is emitted when GTK+ receives an event that indicates that the ownership of the selection associated with clipboard has changed.

Since: 2.6

Connect a signal handler for the “owner-change” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after clipboard #ownerChange callback

Wrap the callback into a Closure.

Generate a function pointer callable from C code, from a C_ClipboardOwnerChangeCallback.

A convenience synonym for Nothing :: Maybe ClipboardOwnerChangeCallback.

Connect a signal handler for the “owner-change” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on clipboard #ownerChange callback

Wrap a ClipboardOwnerChangeCallback into a C_ClipboardOwnerChangeCallback.


text:
# Homework Help: Electric Field Intensity and Infinite Sheet Charges

1. Feb 27, 2015

### BruteCoder

Hey,
Just wanted to thank everyone for their time to help solve people problems, I can generally find all my answers here but I made an account now because i cant seem to find a related problem to this.

In general the textbook for these types of problems make the plane z=something. In this case i am able to use cylindrical coordinate system and solve the problem with ease. However i don't think I can apply that same principle that easily here. The answer for a) is 0.

1. The problem statement, all variables and given/known data
Plane x = 0 has a uniform density ρs, while plane x = a has -ρs. Determine the electric field intensity in regions a) x<0
b) 0<x<a
c) x>a

2. Relevant equations
dQ = ρsdS
E = Q(r-r')/4*pi*ε0*|r-r'|3

3. The attempt at a solution
E
= E1 + E2, where E1 is the electric field due to plane x = 0 and E2 is the electric field due to plane x = a:
a)
Because both are planes:
dS = dydz
For E1:
Q = ∫ ∫ ρs dydz, where both limits are from -infinity to infinity
r = -xâx + yây + zâz ,because x<0
r' = 0âx + y'ây + z'âz
r - r' = -xâx + (y-y')ây + (z-z')âz
|r-r'| = (-x2 + (y-y')2 + (z-z')2)1/2
E1 = 1/(4*π*ε0) ∫ ∫ ρs(-xâx + (y-y')ây + (z-z')âz)/ (x2 + (y-y')2 + (z-z')2)3/2(dydz), where both limits are from -infinity to infinity

At this point I am not sure how to solve these limits, I do know that for infinite sheet charges the only direction that will remain is normal to plane so in this case âx. Am i able to say that (y-y') and (z-z') are equal to zero because regardless where the observation point may be be placed there is a corresponding point on the plane?
If so the equation simplifies too:
E1 = 1/(4*π*ε0) ∫ ∫ ρs(-âx / (x)2(dydz), where both limits are from -infinity to infinity

But the answer to this would be infinity? and I don't understand how we could prove that adding this to E2 would result in 0.

Any help would be appreciated.

Last edited: Feb 27, 2015
2. Feb 27, 2015

### BvU

Ave, Brutus, welcome to PF

I take it $\rho_s$ is a surface charge density ? So you have something like a parallel plate configuration ? Does it say in the exercise text that the plates are conducting ? The the field must be $\perp$ the plates, right ?

Your second equation isn't really very handy in such a case. A plane like x = 0 extends all the way to infinity and y or z components of the field tend to cancel.

3. Feb 27, 2015

### BruteCoder

Yes ρs is surface charge density they didn't give a value for it however it was meant to stay as a variable. No it does not say the plates are conducting I actually copied the question word by word to try to avoid confusion. I thought their may be an easier equation to use, but all textbook examples use the coulomb law equation alone. Like I mentioned though their examples always have the plane z =, in this case cylindrical coordinates make it very easy to solve the problem as dS = [PLAIN]http://mathworld.wolfram.com/images/equations/CylindricalCoordinates/Inline3.gifd[PLAIN]http://mathworld.wolfram.com/images/equations/CylindricalCoordinates/Inline4.gifd[PLAIN]http://mathworld.wolfram.com/images/equations/CylindricalCoordinates/Inline3.gif [Broken] and the limits would be 0-2π for d http://mathworld.wolfram.com/images/equations/CylindricalCoordinates/Inline4.gif and 0-infinty d [PLAIN]http://mathworld.wolfram.com/images/equations/CylindricalCoordinates/Inline3.gif. [Broken] And its also apparent that due to symmetry the http://mathworld.wolfram.com/images/equations/CylindricalCoordinates/Inline3.gif component cancels out, the integral can then be solved with simple substitution. Then they arrive at the equation E = ρs/2ε0âz. They also say that this can be applied to any infinite sheet charge by E = ρs/2ε0ân. Using this it easy to see that the answer is 0 as:
E1 = ρs/2ε0-âx, it's negative because the original equation assumes x>than sheet charge
E2 = -ρs/2ε0-âx
However deriving this from the values in the question alone seem very difficult.

Last edited by a moderator: May 7, 2017
4. Feb 28, 2015

### BvU

This isn't going right at all. Check the link. And check here, where Gauss law is used efficiently.

I can't really decipher E1 = ρs/2ε0-âx . You mean $\vec E_1 = -{\rho_s\over 2\epsilon_0}\; \hat x$ ? And this is for part a) where x < 0 ? (In that case: that is correct).

And then "it's negative because the original equation assumes x>than sheet charge" is gobbledygook: x has a dimension of length, how can it possibly be > than some charge ? What original equation ? E = Q(r-r')/4*pi*ε0*|r-r'|3 ? That doesn't make any assumption at all on $\vec r - \vec r'$ except that it's $\ne$ 0 !

Now the other regions ?

And perhaps afterwards, as an understanding-tester: does it matter whether the plates are conducting or not ?

5. Feb 28, 2015

### BruteCoder

Yes i mean $\vec E_1 = -{\rho_s\over 2\epsilon_0}\; \hat x$, sorry i'm not to good at knowing how to make the symbols correctly. When I meant x>than sheet charge, I should have specified that I meant the sheet charge x position. By the equation i meant the one derived $\vec E_1 = {\rho_s\over 2\epsilon_0}\; \hat z$, it had z>0 and the infinite sheet charge was at z = 0. So it was positive when they took the Z component of $\vec r - \vec r'$. The other regions:

b)
$\vec E_1 = {\rho_s\over 2\epsilon_0}\; \hat x$,
$\vec E_2 = -{\rho_s\over 2\epsilon_0}\;- \hat x$
$\vec E_F = {\rho_s\over\epsilon_0}\;\hat x$
c)
$\vec E_1 = {\rho_s\over 2\epsilon_0}\; \hat x$
$\vec E_1 = -{\rho_s\over 2\epsilon_0}\; \hat x$,
$\vec E_F = 0 \hat x$

Wow after seeing Gauss law being applied I now understand how it can be very useful. It seems it does not matter if the plates are conducting but I am not sure now that its even relevant. Does not two separation of charges mean that they conduct inside of the gap regardless if its explicitly mentioned or not? Lastly the original way i went about solving this problem, is it 'possible' to arrive at the same equation or is it near impossible?

Thanks again.

6. Feb 28, 2015

### BvU

Correct on two counts: it doesn't matter and it's not relevant. The sheets are supposed to be thin and the only thing that counts is the presence of the (surface) charge.

Re original approach: I think it could work. The y and z components go away if you see that $\int_{-\infty}^\infty = \int_{-\infty}^0 + \int_0^\infty$ and the two terms are equal and opposite. x component might well come out to be $2\pi$ if you change from $dydz$ to $\rho d\rho d\phi$.


text:
# PHY454H1S Continuum Mechanics

## Official description

The theory of continuous matter, including solid and fluid mechanics.  Topics include the continuum approximation, dimensional analysis, stress, strain, the Euler and Navier-Stokes equations, vorticity, waves, instabilities, convection and turbulence.

Prerequisite
PHY254H1, MAT235Y1/MAT237Y1/MAT257Y1, APM346H1/APM351Y1
Co-requisite
n.a.
Exclusion
PHY459H1
Recommended preparation
n.a.
Textbook
                            ['no required textbook but will use the information at http://go.utlib.ca/cat/11261467 (or http://go.utlib.ca/cat/10170905)', 'The following book is also recommended - http://go.utlib.ca/cat/8220558']

BR=5
Distribution requirement
DR=SCI

The theory of continuous matter, with a strong focus on fluid mechanics.  Topics include (but may not be limited to) the continuum approximation, dimensional analysis, stress and strain tensors, linear and isotropic elasticity, the Euler and Navier-Stokes equations, conservation laws in fluids, vorticity, potential flows, and water waves.

course title
PHY454H1S
session
winter
year of study
4th year
time and location
24L: LEC0101, LEC2001: MW11, all Lectures in Room: MP134 12T: TUT0101: R11, Room: MP134
instructor
Dylan Jones

#### Delivery Methods

In Person

A course is considered In Person if it requires attendance at a specific location and time for some or all course activities.*.

* Subject to adjustments imposed by public health requirements for physical distancing.

Online - Synchronous
A course is considered Online Synchronous if online attendance is expected at a specific time for some or all course activities, and attendance at a specific location is not expected for any activities or exams.
Asynchronous
A course is considered Asynchronous if it has no requirement for attendance at a specific time or location for any activities or exams.


text:
# Could you actually conduct the ladder paradox problem experimentally?

The very famous ladder paradox says that if you take a ladder of length $$l$$ and a barn of length $$l + dl$$ and put the ladder on a cart traveling toward the barn, you can fit the ladder inside the barn if the cart travels fast enough. This is due to length contraction, which says that a person in a non-moving reference frame will measure the length of moving objects to be shortened. However, Penrose and Terrell showed that one can not observe any such shortening when viewing a moving object. Furthermore, the object does not physically change length. So now suppose you have the technology to try and conduct the ladder paradox experiment; you have the cart that can travel up to 0.99c, you have the ladder, and you have the barn, and you want to try and fit the ladder into the barn. You start up the cart and get it going to 0.99c with the ladder attached. Since you measure the ladder to be shorter, you know you should be able to close both barn doors while the ladder is inside the barn, at some point in time. But you also know that you can't ever physically see the ladder contained inside the barn. Suppose, then, that you say that what you see isn't really what's happening at that instance; maybe at some point you see the ladder sticking out of the barn, but it is really contained fully inside the barn, and maybe you can close the doors then (you are assuming that some weird optical effects are happening while trying to find a solution to the issue). Well, that doesn't solve the problem because this "solution" implies you would have to see the doors cutting through (or hitting the ends) of the ladder, which obviously makes no sense. So the only solution that is really left is that you see the ladder fully outside the barn, you calculate that at that moment it is actually fully contained inside the barn, and you close the doors at that moment. But now what if you have cameras installed at the two sets of doors, and you have the cameras take a picture as soon as the doors close? What do they see? If they see the ladder fully contained inside the barn, then the ladder has actually become shorter, which of course can't happen. But since they can't see the ladder partially sticking out of the barn (the doors are closed!), this means they must capture an empty barn. So the ladder really isn't inside the barn at that time, which suggests that while you can measure the ladder to be fully inside the barn at some time t, it cannot actually ever be fully contained inside the barn (which could of course be seen without this whole discussion by noting that length contraction does not actually happen).

The conclusion, then, seems to be that you can measure that an event happens even though it never actually happens. Is this the correct conclusion, or am I missing something? It seems like a pretty big conclusion that isn't discussed very often, which is why I'm uncertain of its validity. I'm not sure what parts of what I said would be incorrect though. I think my arguments rest on three main assumptions; length contraction can be measured, it can't be observed, and it doesn't physically happen. I'm near certain these are correct assumptions, so I'm not sure where else my arguments fail.

• We must be careful with "the object does not physically change length". The question then is "what is a physical change of length?" and analysing it we see that the notions of "physical length" and "physical change of length" are circular and without any clear meaning. Length is an observer-dependent notion, so we can only ask "what's the change in length measured by this or that observer?". – pglpm Nov 30 '20 at 9:19
• FWIW, we actually can do a version of this experiment, using bunches of particles travelling inside a particle accelerator like the LHC. Admittedly, a bunch of particles isn't exactly the same as a (relatively) rigid ladder. – PM 2Ring Nov 30 '20 at 10:32
• Don't worry about what you can see, worry about what is the case. What happens is essentially a bunch of worldlines in spacetime. – Andrew Steane Nov 30 '20 at 21:50
• @pglpm Is it possible to take a picture or otherwise somehow confirm that the ladder is fully contained inside the barn at some time though? Also, say I'm standing outside the barn watching everything happen. Since I can't see the contraction happen, when the doors close, do I see the ladder fully outside the barn? – Marcel Mazur Dec 1 '20 at 5:46
• To check that the ladder is fully in the barn, one can close the door after the back end of the ladder comes in. Then, one can open the front to let the ladder out. The issue then becomes: were the doors both shut at the same time, for a short while at least? The answer depends on how you define "simultaneous"; it amounts to picking a line in spacetime and announcing "events along this line are simultaneous, according to the reference frame which I have adopted" (e.g. the frame in which the barn is at rest). – Andrew Steane Dec 1 '20 at 10:34

Yes, we really can do a version of this experiment that demonstrates that length contraction is real. Of course we can't do it with a ladder, barn, and cart, but we can do it with groups of particles in a particle accelerator. For example, proton experiments in the LHC use groups of protons (known as bunches) with a distance of about 7 metres (25 nanoseconds) between each bunch in the beam. These protons travel at ultra-relativistic speeds, with a Lorentz factor of over 7000, so the length of a bunch (and of the protons themselves) in the lab frame is less than 1/7000 of its rest frame length. Obviously, such extreme contraction has to be taken into account when planning experiments.

Furthermore, the object does not physically change length.

It's true that the length of the ladder in its rest frame is invariant, but that doesn't mean that length contraction is merely some kind of optical illusion. It's a genuine physical phenomenon that arises because the space & time axes in one rest frame aren't parallel to the space & time axes of another rest frame in relative motion to the first frame.

The Lorentz transformations guarantee that all observers will calculate the same rest length for the ladder no matter what contracted length they measure for it in their rest frame. However, the length (and orientation of the ladder) that each observer and their camera sees is different from what they measure, due to the finite time it takes for light to travel from the various objects to the camera (which is what causes Penrose-Terrell rotation). So to say what's really happening in a given frame we need to be careful to separate those light delay effects from the effects due to spacetime axes rotation.

(Note that the human eye isn't very useful in this scenario, since a ladder moving at 0.99c travels almost 300 km in a millisecond).

Due to the light delay, a picture doesn't show what's happening at all locations in the barn simultaneously. Different parts of the picture show what was happening at different times. The usual way of dealing with that (both in thought experiments and particle collider experiments) is to have a set of cameras (with built-in clocks, with the clocks all synchronised) at different locations, with each camera only photographing what's right in front of it. That is, each camera only measures what's local to it.

So we can have a set of synchronised cameras at various locations in & around the barn, and after the ladder has passed through we can use the timestamps on each image to reconstruct what happened in the barn frame. We can have another set of synchronised cameras mounted on the ladder & cart. But those two sets of cameras cannot be synchronised with each other because they are in relative motion, so their definitions of "now" are incompatible.

Here's a diagram of spacetime axes rotation from Wikipedia's article on the relativity of simultaneity. This diagram is for a 2D spacetime, i.e., one dimension of time and one dimension of space, but that's really all you need when the motion is linear.

Events A, B, and C occur in different order depending on the motion of the observer. The white line represents a plane of simultaneity being moved from the past to the future.

Your ladder is moving at 0.99c, so it has a Lorentz factor $$\gamma$$ in the barn frame of almost 7.09, (~ 1/0.141), so a ladder of rest length 70 metres will just fit into a barn that's 10 metres long, with both doors shut in the barn frame. That's possible because the events of the doors being closed are not simultaneous in the ladder rest frame. In fact, in the ladder's frame, it's the barn that's length contracted, down to a mere 1.41 metres.

In each frame, the front door closes after the rear of the ladder passes it, and the back door opens before the front of the ladder reaches it. That has to be the case to avoid ladder-door collisions. If there's a collision in one frame, there must be a collision in every frame (and vice versa), otherwise we'd lose physical coherency. Relativity may be counter-intuitive from the perspective of pre-relativistic physics, but it's not that crazy. ;) A collision is a localised event in spacetime. Different observers may disagree on the spacetime coordinates of events, and as the above diagram shows, they may even disagree on the temporal order of events that are separated in space, but they all agree on which events do actually happen and which ones don't happen.

So in the ladder's frame, the back door opens in plenty of time for the front of the ladder to pass through it, and the front door doesn't close until after the rear of the ladder has passed it, by which time in the ladder frame the front of the ladder is well past the open back door.

But now what if you have cameras installed at the two sets of doors, and you have the cameras take a picture as soon as the doors close? [...] they can't see the ladder partially sticking out of the barn (the doors are closed!)

The spacetime events of the two doors closing are spacelike separated. This means that at the time either door closes, the light showing the other door closing hasn't crossed the barn yet. So both cameras will in fact record the other door open and the ladder sticking part way out of it.

A camera placed in the middle of the barn and triggered at the right moment will capture a picture of the ladder fully contained in the barn with both doors closed.

I think this question can be quickly answered by referring to the Wikipedia page on length contraction, specifically the experimental verification and visual effects sections. Basically, the problem involves the distance from the space occupied by the ladder. According to this page (https://en.wikipedia.org/wiki/Length_contraction), there are indirect measures of length contraction. In other words, I suspect the issue is with arguing that length contraction both can be measured and cannot be observed (which appears to be a contradiction)...

A quick, visual answer to your question is given by the videos of wheels at the Space Time Travel site. Imagine you had a giant wheel with rest diameter $$l$$ rolling into the barn, instead of a ladder. You can imagine a stationary (for you) "mini-barn" in those videos, placed between the stationary wheels.

One of the lessons (re)emphasized by Einstein and relativity is that before answering a question we must make sure that the question is meaningful and not self-contradictory. Questions such as "What's the formula for the area of the square, given its radius?" or "Is the electromagnetic force blue or red?" contain contradictions or are just meaningless.

One part of the question you ask, "What would I see (standing in such-and-such position)?" or "What would a photograph taken at that instant by a camera (positioned so-and-so) show?" is meaningful and free of contradictions, so it can be certainly answered. What I personally am not sure of are other details, for example the doors. The doors will have to move, so relativistic optical effects will concern them too. And can they be accelerated and moved fast enough, compatibly with relativity, to be seen as closed with the ladder inside? A (3+1)D or maybe just (2+1)D spacetime diagram and some calculations are necessary to first check that your full thought-experiment doesn't contain contradictions. I personally don't know the answer to this at the moment.

Let me consider a simpler thought-experiment. If the barn lacked the short sides (where the doors should be) and lacked one of the long sides (of rest length $$l -\Delta l$$, with $$\Delta l >0$$) – a sort of huge bus-stop shelter – and you were outside of it, at rest with respect to it, so that you can see inside and you're symmetrically placed with respect to its short sides, then you'd see the ladder momentarily fully inside the barn, but you'd also see it rotated, with its front-moving end rotated away from you, and its rear-moving end rotated towards you. So I imagine that you might consider this as "cheating": you can see it fully inside the barn, even if its length (at rest) is longer than the barn's (at rest), but just because it's been rotated. The videos I mentioned at the beginning show this. Compare also the pictures and calculations for the case of a cube in this Physics World article; you may imagine a ladder with its ends constantly touching some sides or edges of the cube, and deduce what you'd see.

The question "Does the object physically change length?", related to a statement you make, is likely to contain contradictions. What do you mean by "physically"? and even by "to change length"? I think that if you analyse the words in this question you'll realize that it has undefined or meaningless terms within relativity.

Apologies for not being able to give a straight answer to the meaningful questions you ask.


text:
# Generating functions for certain statistics on Coxeter groups of type B

Background

In combinatorics one is sometimes interested in various 'statistics' on a Coxeter group (e.g., functions from the group to the natural numbers), and to find a 'nice' expression for a corresponding generating function. For example, the length function $l$ on a Coxeter group $W$ is an important statistic, and when $W=S_{n}$ is the symmetric group on $n$ letters, a classical result of this type is the identity $$\sum_{w\in S_{n}}t{}^{l(w)}=\prod_{i=1}^{n}\frac{1-t^{i}}{1-t},$$

where $t$ is an indeterminate (cf. Stanley, Enumerative Combinatorics, vol. 1, Coroll. 1.3.10). There are also variations on the problem, where one considers sums over elements $w$ whose right descent set

$$D_{R}(w):=\{x\in W\mid l(wx)<l(w)\}$$

is contained in a given subset $I\subseteq S$ of the fundamental reflections $S$ of the group $W$. There are several examples in the literature of sums of the form $$\sum_{\substack{w\in W\\ D_{R}(w)\subseteq I} }t^{f(w)}\quad\text{or}\sum_{\substack{w\in W\\ D_{R}(w)\subseteq I} }(-1)^{l(w)}t^{f(w)},$$

where $f:W\rightarrow\mathbb{N}$ is a given statistic on $W$, and it is sometimes possible to express these generating functions in a (non-trivial) simple algebraic way, as in the above example.

Let $[n]$ denote the set $\{1,2,\dots,n\}$, and let $S_{n}^{B}$ be the signed permutation group, that is, the group of all bijections $w$ of the set $[\pm n]=\{\pm1,\pm2,\dots,\pm n\}$, such that $w(-a)=-a$, for all $a$ in the set (cf. Björner \& Brenti: Combinatorics of Coxeter Groups, 8.1). If $w\in S_{n}^{B}$, we write $w=[a_{1},\dots,a_{n}]$ to mean $w(i)=a_{i}$, for $i=1,\dots,n$. For $i\in[n-1]$, the $i$th Coxeter generator of $S_{n}^{B}$ is given by $$s_{i}:=[1,\dots,i-1,i+1,i,i+2,\dots,n],$$ and we also put $$s_{0}:=[-1,2,\dots,n].$$

We may therefore identify the set of generators $s_{i}$ with the set $[n-1]_{0}:=[n-1]\cup\{0\}$. Hence, for any subset $I\subseteq[n-1]_{0}$, we write $D_{R}(w)\subseteq I$ rather than $D_{R}(w)\subseteq\{s_{i}\mid i\in I\}$.

Questions

In addition to defining a collection of generators, a set $I=\{i_{1},\dots,i_{l}\}\subseteq[n-1]_{0}$, with $i_{1}<i_{2}<\cdots<i_{l}$ also defines the following polynomial (related to Gaussian polynomials):

$$\alpha_{I,n}(t):=\frac{(\underline{n})!}{(\underline{i_{1}})!\prod_{r=1}^{l}\prod_{s=1}^{\lfloor(i_{r+1}-i_{r})/2\rfloor}(\underline{2s})}.$$

Here $\lfloor\cdot\rfloor$ denotes the floor function, and we use the notation $(\underline{0}):=1$, $(\underline{a}):=1-t^{a}$, for $a\geq1$, and $(\underline{a})!:=(\underline{1})(\underline{2})\cdots(\underline{a})$. To get a correct formula, we also put $i_{l+1}:=n$.}

Define the following statistic on $S_{n}^{B}$: $$\tilde{L}(w):=\frac{1}{2}|\{x,y\in[\pm n]\mid x<y,\ w(x)>w(y),\ x\not\equiv y\pmod{2}\}|.$$

The question is now:

Is it true that for any $n$ and $I$ as above, we have

$$\alpha_{I,n}(t)=\sum_{\substack{w\in S_{n}^{B}\\ D_{R}(w)\subseteq I} }(-1)^{l(w)}t^{\tilde{L}(w)}?$$

A less precise but more general question is the following: Given a family of polynomials $p_{I,n}(t)\in\mathbf{Z}[t]$ depending on $I$ and $n$, is there any general (non-trivial) sufficient criterion for the existence of functions $f,g:W\rightarrow\mathbb{N}$ on a finite Coxeter group $W$, such that for all $I$ and $n$, we have

$$p_{I,n}(t)=\sum_{\substack{w\in W\\ D_{R}(w)\subseteq I} }a^{f(w)}t^{g(w)},$$ for some $a\in\mathbf{Z}$?

-
It's a pity to see you have put in so much effort in posing this question and no one seems to know how to answer it... –  Max Muller May 16 '10 at 21:52


text:
# Maharashtra Board Class 9 Maths Solutions Chapter 3 Triangles Practice Set 3.5

## Maharashtra State Board Class 9 Maths Solutions Chapter 3 Triangles Practice Set 3.5

Question 1.
If ∆XYZ ~ ∆LMN, write the corresponding angles of the two triangles and also write the ratios of corresponding sides.
Solution:
∆XYZ ~ ∆LMN [Given]
∴ ∠X ≅ ∠L
∠Y ≅ ∠M >
∠Z ≅ ∠N [Corresponding angles of similar triangles]
$$\frac{\mathrm{XY}}{\mathrm{LM}}=\frac{\mathrm{YZ}}{\mathrm{MN}}=\frac{\mathrm{XZ}}{\mathrm{LN}}$$ [Corresponding sides of similar triangles]

Question 2.
In ∆XYZ, XY = 4 cm, YZ = 6 cm, XZ = 5 cm. If ∆XYZ ~ ∆PQR and PQ = 8 cm, then find the lengths of remaining sides of ∆PQR.
Solution:
∆XYZ ~ ∆PQR [Given]
∴ $$\frac{\mathrm{XY}}{\mathrm{PQ}}=\frac{\mathrm{YZ}}{\mathrm{QR}}=\frac{\mathrm{XZ}}{\mathrm{PR}}$$ [Corresponding sides of similar triangles]

∴ PR = 10 cm
∴ QR = 12 cm, PR = 10cm

Question 3.
Draw a sketch of a pair of similar triangles. Label them. Show their corresponding angles by the same signs. Show the lengths of corresponding sides by numbers in proportion.
Solution:

∆GHI ~ ∆STU

Maharashtra Board Class 9 Maths Chapter 3 Triangles Practice Set 3.5 Intext Questions and Activities

Question 1.
We have learnt that if two triangles are equiangular then their sides are in proportion. What do you think if two quadrilaterals are equiangular? Are their sides in proportion? Draw different figures and verify. Verify the same for other polygons. (Textbook pg no 50)
If two quadrilaterals are equiangular then their sides will not necessarily be in proportion.
Case 1: The two quadrilaterals are of the same type.

Consider squares ABCD and PQRS.
∠A = ∠P, ∠B = ∠Q, ∠C = ∠R, ∠D = ∠S
$$\frac{\mathrm{AB}}{\mathrm{PQ}}=\frac{\mathrm{BC}}{\mathrm{QR}}=\frac{\mathrm{CD}}{\mathrm{RS}}=\frac{\mathrm{AD}}{\mathrm{PS}}$$

Case 2: The two quadrilaterals are of different types.

Consider square ABCD and rectangle STUV.
∠A = ∠S, ∠B = ∠T, ∠C = ∠U, ∠D = ∠V

Scroll to Top


text:
/

# Operator¶

Quantum mechanical operators.

TODO:

• Fix early 0 in apply_operators.
• Debug and test apply_operators.
• Get cse working with classes in this file.
• Doctests and documentation of special methods for InnerProduct, Commutator, AntiCommutator, represent, apply_operators.
class sympy.physics.quantum.operator.Operator[source]

Base class for non-commuting quantum operators.

An operator maps between quantum states [R235]. In quantum mechanics, observables (including, but not limited to, measured physical values) are represented as Hermitian operators [R236].

Parameters : args : tuple The list of numbers or parameters that uniquely specify the operator. For time-dependent operators, this will include the time.

References

 [R236] (1, 2) http://en.wikipedia.org/wiki/Observable

Examples

Create an operator and examine its attributes:

>>> from sympy.physics.quantum import Operator
>>> from sympy import symbols, I
>>> A = Operator('A')
>>> A
A
>>> A.hilbert_space
H
>>> A.label
(A,)
>>> A.is_commutative
False

Create another operator and do some arithmetic operations:

>>> B = Operator('B')
>>> C = 2*A*A + I*B
>>> C
2*A**2 + I*B

Operators don’t commute:

>>> A.is_commutative
False
>>> B.is_commutative
False
>>> A*B == B*A
False

Polymonials of operators respect the commutation properties:

>>> e = (A+B)**3
>>> e.expand()
A*B*A + A*B**2 + A**2*B + A**3 + B*A*B + B*A**2 + B**2*A + B**3

Operator inverses are handle symbolically:

>>> A.inv()
A**(-1)
>>> A*A.inv()
1

class sympy.physics.quantum.operator.HermitianOperator[source]

A Hermitian operator that satisfies H == Dagger(H).

Parameters : args : tuple The list of numbers or parameters that uniquely specify the operator. For time-dependent operators, this will include the time.

Examples

>>> from sympy.physics.quantum import Dagger, HermitianOperator
>>> H = HermitianOperator('H')
>>> Dagger(H)
H

class sympy.physics.quantum.operator.UnitaryOperator[source]

A unitary operator that satisfies U*Dagger(U) == 1.

Parameters : args : tuple The list of numbers or parameters that uniquely specify the operator. For time-dependent operators, this will include the time.

Examples

>>> from sympy.physics.quantum import Dagger, UnitaryOperator
>>> U = UnitaryOperator('U')
>>> U*Dagger(U)
1

class sympy.physics.quantum.operator.OuterProduct[source]

An unevaluated outer product between a ket and bra.

This constructs an outer product between any subclass of KetBase and BraBase as |a><b|. An OuterProduct inherits from Operator as they act as operators in quantum expressions. For reference see [R237].

Parameters : ket : KetBase The ket on the left side of the outer product. bar : BraBase The bra on the right side of the outer product.

References

 [R237] (1, 2) http://en.wikipedia.org/wiki/Outer_product

Examples

Create a simple outer product by hand and take its dagger:

>>> from sympy.physics.quantum import Ket, Bra, OuterProduct, Dagger
>>> from sympy.physics.quantum import Operator

>>> k = Ket('k')
>>> b = Bra('b')
>>> op = OuterProduct(k, b)
>>> op
|k><b|
>>> op.hilbert_space
H
>>> op.ket
|k>
>>> op.bra
<b|
>>> Dagger(op)
|b><k|

In simple products of kets and bras outer products will be automatically identified and created:

>>> k*b
|k><b|

But in more complex expressions, outer products are not automatically created:

>>> A = Operator('A')
>>> A*k*b
A*|k>*<b|

A user can force the creation of an outer product in a complex expression by using parentheses to group the ket and bra:

>>> A*(k*b)
A*|k><b|

bra[source]

Return the bra on the right side of the outer product.

ket[source]

Return the ket on the left side of the outer product.

class sympy.physics.quantum.operator.DifferentialOperator[source]

An operator for representing the differential operator, i.e. d/dx

It is initialized by passing two arguments. The first is an arbitrary expression that involves a function, such as Derivative(f(x), x). The second is the function (e.g. f(x)) which we are to replace with the Wavefunction that this DifferentialOperator is applied to.

Parameters : expr : Expr The arbitrary expression which the appropriate Wavefunction is to be substituted into func : Expr A function (e.g. f(x)) which is to be replaced with the appropriate Wavefunction when this DifferentialOperator is applied

Examples

You can define a completely arbitrary expression and specify where the Wavefunction is to be substituted

>>> from sympy import Derivative, Function, Symbol
>>> from sympy.physics.quantum.operator import DifferentialOperator
>>> from sympy.physics.quantum.state import Wavefunction
>>> from sympy.physics.quantum.qapply import qapply
>>> f = Function('f')
>>> x = Symbol('x')
>>> d = DifferentialOperator(1/x*Derivative(f(x), x), f(x))
>>> w = Wavefunction(x**2, x)
>>> d.function
f(x)
>>> d.variables
(x,)
>>> qapply(d*w)
Wavefunction(2, x)

expr[source]

Returns the arbitary expression which is to have the Wavefunction substituted into it

Examples

>>> from sympy.physics.quantum.operator import DifferentialOperator
>>> from sympy import Function, Symbol, Derivative
>>> x = Symbol('x')
>>> f = Function('f')
>>> d = DifferentialOperator(Derivative(f(x), x), f(x))
>>> d.expr
Derivative(f(x), x)
>>> y = Symbol('y')
>>> d = DifferentialOperator(Derivative(f(x, y), x) +
...                          Derivative(f(x, y), y), f(x, y))
>>> d.expr
Derivative(f(x, y), x) + Derivative(f(x, y), y)

free_symbols[source]

Return the free symbols of the expression.

function[source]

Returns the function which is to be replaced with the Wavefunction

Examples

>>> from sympy.physics.quantum.operator import DifferentialOperator
>>> from sympy import Function, Symbol, Derivative
>>> x = Symbol('x')
>>> f = Function('f')
>>> d = DifferentialOperator(Derivative(f(x), x), f(x))
>>> d.function
f(x)
>>> y = Symbol('y')
>>> d = DifferentialOperator(Derivative(f(x, y), x) +
...                          Derivative(f(x, y), y), f(x, y))
>>> d.function
f(x, y)

variables[source]

Returns the variables with which the function in the specified arbitrary expression is evaluated

Examples

>>> from sympy.physics.quantum.operator import DifferentialOperator
>>> from sympy import Symbol, Function, Derivative
>>> x = Symbol('x')
>>> f = Function('f')
>>> d = DifferentialOperator(1/x*Derivative(f(x), x), f(x))
>>> d.variables
(x,)
>>> y = Symbol('y')
>>> d = DifferentialOperator(Derivative(f(x, y), x) +
...                          Derivative(f(x, y), y), f(x, y))
>>> d.variables
(x, y)

Hilbert Space

#### Next topic

Operator/State Helper Functions


text:
Copied to
clipboard

## G = C2×D42order 128 = 27

### Direct product of C2, D4 and D4

direct product, p-group, metabelian, nilpotent (class 2), monomial, rational

Series: Derived Chief Lower central Upper central Jennings

 Derived series C1 — C22 — C2×D42
 Chief series C1 — C2 — C22 — C23 — C24 — C25 — D4×C23 — C2×D42
 Lower central C1 — C22 — C2×D42
 Upper central C1 — C23 — C2×D42
 Jennings C1 — C22 — C2×D42

Generators and relations for C2×D42
G = < a,b,c,d,e | a2=b4=c2=d4=e2=1, ab=ba, ac=ca, ad=da, ae=ea, cbc=b-1, bd=db, be=eb, cd=dc, ce=ec, ede=d-1 >

Subgroups: 2428 in 1268 conjugacy classes, 484 normal (8 characteristic)
C1, C2, C2 [×6], C2 [×24], C4 [×8], C4 [×10], C22, C22 [×22], C22 [×152], C2×C4 [×22], C2×C4 [×42], D4 [×32], D4 [×104], C23, C23 [×32], C23 [×184], C42 [×4], C22⋊C4 [×32], C4⋊C4 [×8], C22×C4, C22×C4 [×22], C22×C4 [×16], C2×D4 [×80], C2×D4 [×180], C24 [×24], C24 [×40], C2×C42, C2×C22⋊C4 [×8], C2×C4⋊C4 [×2], C4×D4 [×16], C22≀C2 [×32], C4⋊D4 [×32], C41D4 [×8], C23×C4 [×4], C22×D4 [×48], C22×D4 [×32], C25 [×4], C2×C4×D4 [×2], C2×C22≀C2 [×4], C2×C4⋊D4 [×4], C2×C41D4, D42 [×16], D4×C23 [×4], C2×D42
Quotients: C1, C2 [×31], C22 [×155], D4 [×16], C23 [×155], C2×D4 [×56], C24 [×31], C22×D4 [×28], 2+ 1+4 [×2], C25, D42 [×4], D4×C23 [×2], C2×2+ 1+4, C2×D42

Smallest permutation representation of C2×D42
On 32 points
Generators in S32
(1 27)(2 28)(3 25)(4 26)(5 10)(6 11)(7 12)(8 9)(13 22)(14 23)(15 24)(16 21)(17 30)(18 31)(19 32)(20 29)
(1 2 3 4)(5 6 7 8)(9 10 11 12)(13 14 15 16)(17 18 19 20)(21 22 23 24)(25 26 27 28)(29 30 31 32)
(1 9)(2 12)(3 11)(4 10)(5 26)(6 25)(7 28)(8 27)(13 30)(14 29)(15 32)(16 31)(17 22)(18 21)(19 24)(20 23)
(1 13 10 31)(2 14 11 32)(3 15 12 29)(4 16 9 30)(5 18 27 22)(6 19 28 23)(7 20 25 24)(8 17 26 21)
(1 29)(2 30)(3 31)(4 32)(5 24)(6 21)(7 22)(8 23)(9 14)(10 15)(11 16)(12 13)(17 28)(18 25)(19 26)(20 27)

G:=sub<Sym(32)| (1,27)(2,28)(3,25)(4,26)(5,10)(6,11)(7,12)(8,9)(13,22)(14,23)(15,24)(16,21)(17,30)(18,31)(19,32)(20,29), (1,2,3,4)(5,6,7,8)(9,10,11,12)(13,14,15,16)(17,18,19,20)(21,22,23,24)(25,26,27,28)(29,30,31,32), (1,9)(2,12)(3,11)(4,10)(5,26)(6,25)(7,28)(8,27)(13,30)(14,29)(15,32)(16,31)(17,22)(18,21)(19,24)(20,23), (1,13,10,31)(2,14,11,32)(3,15,12,29)(4,16,9,30)(5,18,27,22)(6,19,28,23)(7,20,25,24)(8,17,26,21), (1,29)(2,30)(3,31)(4,32)(5,24)(6,21)(7,22)(8,23)(9,14)(10,15)(11,16)(12,13)(17,28)(18,25)(19,26)(20,27)>;

G:=Group( (1,27)(2,28)(3,25)(4,26)(5,10)(6,11)(7,12)(8,9)(13,22)(14,23)(15,24)(16,21)(17,30)(18,31)(19,32)(20,29), (1,2,3,4)(5,6,7,8)(9,10,11,12)(13,14,15,16)(17,18,19,20)(21,22,23,24)(25,26,27,28)(29,30,31,32), (1,9)(2,12)(3,11)(4,10)(5,26)(6,25)(7,28)(8,27)(13,30)(14,29)(15,32)(16,31)(17,22)(18,21)(19,24)(20,23), (1,13,10,31)(2,14,11,32)(3,15,12,29)(4,16,9,30)(5,18,27,22)(6,19,28,23)(7,20,25,24)(8,17,26,21), (1,29)(2,30)(3,31)(4,32)(5,24)(6,21)(7,22)(8,23)(9,14)(10,15)(11,16)(12,13)(17,28)(18,25)(19,26)(20,27) );

G=PermutationGroup([(1,27),(2,28),(3,25),(4,26),(5,10),(6,11),(7,12),(8,9),(13,22),(14,23),(15,24),(16,21),(17,30),(18,31),(19,32),(20,29)], [(1,2,3,4),(5,6,7,8),(9,10,11,12),(13,14,15,16),(17,18,19,20),(21,22,23,24),(25,26,27,28),(29,30,31,32)], [(1,9),(2,12),(3,11),(4,10),(5,26),(6,25),(7,28),(8,27),(13,30),(14,29),(15,32),(16,31),(17,22),(18,21),(19,24),(20,23)], [(1,13,10,31),(2,14,11,32),(3,15,12,29),(4,16,9,30),(5,18,27,22),(6,19,28,23),(7,20,25,24),(8,17,26,21)], [(1,29),(2,30),(3,31),(4,32),(5,24),(6,21),(7,22),(8,23),(9,14),(10,15),(11,16),(12,13),(17,28),(18,25),(19,26),(20,27)])

50 conjugacy classes

 class 1 2A ··· 2G 2H ··· 2W 2X ··· 2AE 4A ··· 4H 4I ··· 4R order 1 2 ··· 2 2 ··· 2 2 ··· 2 4 ··· 4 4 ··· 4 size 1 1 ··· 1 2 ··· 2 4 ··· 4 2 ··· 2 4 ··· 4

50 irreducible representations

 dim 1 1 1 1 1 1 1 2 4 type + + + + + + + + + image C1 C2 C2 C2 C2 C2 C2 D4 2+ 1+4 kernel C2×D42 C2×C4×D4 C2×C22≀C2 C2×C4⋊D4 C2×C4⋊1D4 D42 D4×C23 C2×D4 C22 # reps 1 2 4 4 1 16 4 16 2

Matrix representation of C2×D42 in GL5(ℤ)

 -1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 -1 0 0 0 0 0 -1
,
 1 0 0 0 0 0 1 -2 0 0 0 1 -1 0 0 0 0 0 -1 0 0 0 0 0 -1
,
 1 0 0 0 0 0 1 -2 0 0 0 0 -1 0 0 0 0 0 1 0 0 0 0 0 1
,
 1 0 0 0 0 0 -1 0 0 0 0 0 -1 0 0 0 0 0 -1 -2 0 0 0 1 1
,
 -1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 -1 -2 0 0 0 0 1

G:=sub<GL(5,Integers())| [-1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,-1,0,0,0,0,0,-1],[1,0,0,0,0,0,1,1,0,0,0,-2,-1,0,0,0,0,0,-1,0,0,0,0,0,-1],[1,0,0,0,0,0,1,0,0,0,0,-2,-1,0,0,0,0,0,1,0,0,0,0,0,1],[1,0,0,0,0,0,-1,0,0,0,0,0,-1,0,0,0,0,0,-1,1,0,0,0,-2,1],[-1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,-1,0,0,0,0,-2,1] >;

C2×D42 in GAP, Magma, Sage, TeX

C_2\times D_4^2
% in TeX

G:=Group("C2xD4^2");
// GroupNames label

G:=SmallGroup(128,2194);
// by ID

G=gap.SmallGroup(128,2194);
# by ID

G:=PCGroup([7,-2,2,2,2,2,-2,2,477,1430,570]);
// Polycyclic

G:=Group<a,b,c,d,e|a^2=b^4=c^2=d^4=e^2=1,a*b=b*a,a*c=c*a,a*d=d*a,a*e=e*a,c*b*c=b^-1,b*d=d*b,b*e=e*b,c*d=d*c,c*e=e*c,e*d*e=d^-1>;
// generators/relations

׿
×
𝔽