text:
10 Answered Questions for the topic Graph Equation Slope

Graph Equation Slope

10/23/17

#### On the coordinate plane draw the graphs of the following equations

-3+2x=y/3
Graph Equation Slope

02/21/16

#### How do I graph -3x + 5y = -10

Each axis is one unit
Graph Equation Slope

12/15/15

#### equation of the line perpendicular to y=-6x+17 and through (18,-9)

i don't get this
Graph Equation Slope Using A Point And The Slope

11/16/14

i need  help

#### I need help on 2 things based on this word problem.

The student council is planning a party at the skating rink. There is a $100 fee to reserve the rink for the party. It will also cost$5 per person, which includes the rental skates and snacks. a.... more
Graph Equation Slope Slope Intercept Form Slope Equation

03/19/13

#### Find the slope of the line that is perpendicular to x-y=3

Graph equation and show work step by step
Graph Equation Slope

02/14/13

#### how do you graph a -1/5 slope

Which direction would it go in?
Graph Equation Slope Math Algebra 1 Algebra

02/13/13

#### The correct x-intercept and y-intercept of the graph of the equation 3x - 4y = -12.

I got intercept = (3, 0); y-intercept = (0, -4). Am I right?
Graph Equation Slope

02/13/13

#### y= -5x+9 5x+y = -21

Determine weather the graphs of the given equation are parallel, perpendicular, or neither. Explain
Graph Equation Slope

02/13/13

#### x=1/4 y=1/10

Determine weather the graphs of the given equation are parallel, perpendicular, or neither. Explain

## Still looking for help? Get the right answer, fast.

Get a free answer to a quick problem.
Most questions answered within 4 hours.

#### OR

Choose an expert and meet online. No packages or subscriptions, pay only for the time you need.


text:
# Queues and agents¶

 Agent The base class for an agent. InfoAgent An agent that carries information about the QueueNetwork around. InfoQueue A queue that stores information about the network. GreedyAgent An agent that chooses the queue with the shortest line as their next destination. LossQueue A finite capacity queue. NullQueue A terminal queue. poisson_random_measure A function that returns the arrival time of the next arrival for a Poisson random measure. QueueServer The base queue-server class. ResourceAgent An agent designed to interact with the ResourceQueue class. ResourceQueue An queue designed to interact with the ResourceAgent class.

## Queues¶

class queueing_tool.queues.QueueServer(num_servers=1, edge=(0, 0, 0, 1), arrival_f=lambda t: t + np.random.exponential(1), service_f=lambda t: t + np.random.exponential(0.9), AgentFactory=Agent, keep_data=False, active_cap=np.infty, deactive_t=np.infty, coloring_sensitivity=2, **kwargs)[source]

The base queue-server class.

Built to work with the QueueNetwork class, but can stand alone as a multi-server queue. It supports a capped pool of potential arrivals using the active_cap attribute, as well as the stopping time attribute, deactive_t, after which no more arrivals can enter the queue. When connected to a network of queues via a QueueNetwork, the active_cap and deactive_t attributes applies only to arrivals from outside the network; the QueueServer instance always accepts arrivals from other queues inside the QueueNetwork.

This class supports arbitrary arrival and service distribution functions (that can depend on time but do not on the state of the system).

Note that of the following parameters are assigned to an attribute of the same name.

Parameters: num_servers : int or numpy.infty (optional, default: 1) The number of servers servicing agents. arrival_f : function (optional, default: lambda t: t + exponential(1)) A function that returns the time of next arrival from outside the network. When this function is called, t is always taken to be the current time. service_f : function (optional, default: lambda t: t + exponential(0.9)) A function that returns the time of an agent’s service time. When this function is called, t is the time the agent is entering service. edge : 4-tuple of int (optional, default: (0, 0, 0, 1)) A tuple that uniquely identifies which edge this queue lays on and the edge type. The first slot of the tuple is the source vertex, the second slot is the target vertex, and the third slot is the edge_index of that edge, and the last slot is the edge type for this queue. This is automatically created when a QueueNetwork instance is created. AgentFactory : class (optional, default: the Agent class) Any function that can create agents. Note that the function must take one parameter. active_cap : int (optional, default: infty) The maximum number of arrivals the queue will accept from outside the network. deactive_t : float (optional, default: infty) Sets a stopping time, after which no more arrivals (from outside the network) will attempt to enter the QueueServer. collect_data : bool (optional, default: False) A bool that defines whether the queue collects each Agent's arrival, service start, and departure times and other data. See fetch_data() for more on the information that is collected. colors : dict (optional) A dictionary of the colors used when drawing the graph. The possible colors are: edge_loop_color The default color of the edge if the edge is a loop. edge_color The normal color a non-loop edge. vertex_fill_color The normal fill color for a vertex; this also colors the target vertex in the graph if the edge is a loop. vertex_color The color of the vertex border if the edge is a loop. The defaults are listed in the notes. coloring_sensitivity : int (optional, default: 2) Specifies how sensitive the coloring of the queue is to the number of arrivals. See the notes for how this parameter affects coloring. seed : int (optional) If supplied seed is used to initialize numpy’s psuedo-random number generator.

Notes

This is a generic multi-server queue implimentation (see [R11]). In Kendall’s notation, this is a $$\text{GI}_t/\text{GI}_t/c/\infty/N/\text{FIFO}$$ queue class, where $$c$$ is set by num_servers and $$N$$ is set by active_cap. See chapter 1 of [R10] (pdfs from the author and the publisher) for a good introduction to the theory behind the multi-server queue.

Each queue sits on an edge in a graph. When drawing the graph, the queue colors the edges. If the target vertex does not have any loops, the number of agents in this queue affects the target vertex’s color as well.

Some defaults:

>>> default_colors = {
...     'edge_loop_color'   : [0, 0, 0, 0],
...     'edge_color'        : [0.9, 0.9, 0.9, 0.5],
...     'vertex_fill_color' : [1.0, 1.0, 1.0, 1.0],
...     'vertex_color'      : [0.0, 0.5, 1.0, 1.0]
... }

If the queue is in a QueueNetwork and lies on a non-loop edge, the coloring of the edge is given by the following code:

>>> div = coloring_sensitivity * num_servers + 1.
>>> tmp = 1. - min(num_system / div, 1)
>>> color = [i * tmp for i in colors['edge_color']]
>>> color[3] = 1 / 2.

References

 [R10] (1, 2) Harchol-Balter, Mor. Performance Modeling and Design of Computer Systems: Queueing Theory in Action. Cambridge University Press, 2013. ISBN: 9781107027503.
 [R11] (1, 2) Queueing Theory, Wikipedia http://en.wikipedia.org/wiki/Queueing_theory.

Examples

The following code constructs an $$\text{M}_t/\text{GI}/5$$ QueueServer with mean utilization rate $$\rho = 0.8$$. The arrivals are modeled as a Poisson random measure with rate function $$r(t) = 2 + 16 \sin^2(\pi t / 8)$$ and a service distribution that is gamma with shape and scale parameters 4 and 0.1 respectively. To create such a queue run:

>>> import queueing_tool as qt
>>> import numpy as np
>>> def rate(t): return 2 + 16 * np.sin(np.pi * t / 8)**2
>>> def arr(t): return qt.poisson_random_measure(t, rate, 18)
>>> def ser(t): return t + np.random.gamma(4, 0.1)
>>> q = qt.QueueServer(5, arrival_f=arr, service_f=ser)

Before you can simulate the queue, it must be set to active; also, no data is collected by default, we change these with the following:

>>> q.set_active()
>>> q.collect_data = True

To simulate 12000 events and collect the data run

>>> q.simulate(n=12000)
>>> data = q.fetch_data()

Attributes

 active (bool) Returns whether the queue accepts arrivals from outside the network (the queue will always accept arrivals from inside the network). The default is False. To change call set_active(). coloring_sensitivity (int) Specifies how sensitive the coloring of the edge is to the number of arrivals. current_time (float) The time of the last event. data (dict) Keeps track of each Agent's arrival, service start, and departure times, as well as how many other agents were waiting to be served and the total number agents in the system (upon arrival). The keys are the Agent's unique agent_id, and the values is a list of lists. Each time an agent arrives at the queue it appends this data to the end of the list. Use fetch_data() to retrieve a formated version of this data. num_arrivals (list) A list with two entries. The first slot is the total number of arrivals, while the second slot is the number of arrivals from outside the network. num_departures (int) The total number of departures from the queue. num_system (int) The number of agents in the entire QueueServer – this includes those being served and those waiting to be served. queue (deque) A queue for the agents waiting to enter service. time (float) The time of the next event.
at_capacity()[source]

Returns whether the queue is at capacity or not.

Returns: bool Always returns False, since the QueueServer class has infinite capacity.
clear()[source]

Clears out the queue. Removes all arrivals, departures, and queued agents from the QueueServer, resets num_arrivals, num_departures, num_system, and the clock to zero. It also clears any stored data and the server is then set to inactive.

copy()[source]

Returns a deep copy of itself.

delay_service(t=None)[source]

Adds an extra service time to the next departing Agent's service time.

Parameters: t : float (optional) Specifies the departing time for the agent scheduled to depart next. If t is not given, then an additional service time is added to the next departing agent.
fetch_data(return_header=False)[source]

Fetches data from the queue.

Parameters: return_header : bool (optonal, default: False) Determines whether the column headers are returned. data : ndarray A six column ndarray of all the data. The columns are: 1st: The arrival time of an agent. 2nd: The service start time of an agent. 3rd: The departure time of an agent. 4th: The length of the queue upon the agents arrival. 5th: The total number of Agents in the QueueServer. 6th: The QueueServer's edge index. headers : str (optional) A comma seperated string of the column headers. Returns 'arrival,service,departure,num_queued,num_total,q_id'
next_event()[source]

Simulates the queue forward one event.

Use simulate() instead.

Returns: out : Agent (sometimes) If the next event is a departure then the departing agent is returned, otherwise nothing is returned.

simulate()
Simulates the queue forward.
next_event_description()[source]

Returns an integer representing whether the next event is an arrival, a departure, or nothing.

Returns: out : int An integer representing whether the next event is an arrival or a departure: 1 corresponds to an arrival, 2 corresponds to a departure, and 0 corresponds to nothing scheduled to occur.
number_queued()[source]

Returns the number of agents waiting in line to be served.

Returns: out : int The number of agents waiting in line to be served.
set_active()[source]

Changes the active attribute to True. Agents may now arrive from outside the network.

set_inactive()[source]

Changes the active attribute to False.

set_num_servers(n)[source]

Change the number of servers in the queue to n.

Parameters: n : int or numpy.infty A positive integer (or numpy.infty) to set the number of queues in the system to. TypeError If n is not an integer or positive infinity then this error is raised. ValueError If n is not positive.
simulate(n=1, t=None, nA=None, nD=None)[source]

This method simulates the queue forward for a specified amount of simulation time, or for a specific number of events.

Parameters: n : int (optional, default: 1) The number of events to simulate. If t, nA, and nD are not given then this parameter is used. t : float (optional) The minimum amount of simulation time to simulate forward. nA : int (optional) Simulate until nA additional arrivals are observed. nD : int (optional) Simulate until nD additional departures are observed.

Examples

Before any simulations can take place the QueueServer must be activated:

>>> import queueing_tool as qt
>>> import numpy as np
>>> rate = lambda t: 2 + 16 * np.sin(np.pi * t / 8)**2
>>> arr = lambda t: qt.poisson_random_measure(t, rate, 18)
>>> ser = lambda t: t + np.random.gamma(4, 0.1)
>>> q = qt.QueueServer(5, arrival_f=arr, service_f=ser, seed=54)
>>> q.set_active()

To simulate 50000 events do the following:

>>> q.simulate(50000)
>>> num_events = q.num_arrivals[0] + q.num_departures
>>> num_events
50000

To simulate forward 75 time units, do the following:

>>> t0 = q.time
>>> q.simulate(t=75)
>>> round(float(q.time - t0), 1)
75.1
>>> q.num_arrivals[1] + q.num_departures - num_events
1597

To simulate forward until 1000 new departures are observed run:

>>> nA0, nD0 = q.num_arrivals[1], q.num_departures
>>> q.simulate(nD=1000)
>>> q.num_departures - nD0, q.num_arrivals[1] - nA0
(1000, 983)

To simulate until 1000 new arrivals are observed run:

>>> nA0, nD0 = q.num_arrivals[1], q.num_departures
>>> q.simulate(nA=1000)
>>> q.num_departures - nD0, q.num_arrivals[1] - nA0,
(987, 1000)

class queueing_tool.queues.LossQueue(qbuffer=0, **kwargs)[source]

Bases: queueing_tool.queues.queue_servers.QueueServer

A finite capacity queue.

If an agent arrives to a queue that is at capacity, then the agent gets blocked. If this agent is arriving from inside the network then that agent has to stay at their current queue. If the agent is arriving from outside the network then the agent is deleted.

Parameters: qbuffer : int (optional, default: 0) Specifies the maximum number of agents that can be waiting to be serviced. **kwargs Any QueueServer parameters.

Notes

In Kendall’s notation, this is a $$\text{GI}_t/\text{GI}_t/c/c+b/N/\text{FIFO}$$ queue, where $$b$$ is the qbuffer. If the default parameters are used then the instance is an $$\text{M}/\text{M}/1/1$$ queue.

Attributes

 num_blocked (int) The number of times arriving agents have been blocked because the server was full. buffer (int) Specifies how many agents can be waiting to be serviced.
at_capacity()[source]

Returns whether the queue is at capacity or not.

Returns: out : bool Returns whether the number of agents in the system – the number of agents being serviced plus those waiting to be serviced – is equal to num_servers + buffer.
class queueing_tool.queues.InfoQueue(net_size=1, AgentFactory=InfoAgent, qbuffer=np.infty, **kwargs)[source]

Bases: queueing_tool.queues.queue_servers.LossQueue

A queue that stores information about the network.

This queue gets information about the state of the network (number of Agent's at other queues) from arriving InfoAgent's. When an InfoAgent arrives, the queue extracts all the information the agent has and replaces it’s out-of-date network information with the agents more up-to-date information (if the agent has any). When an InfoAgent departs this queue, the queue gives the departing agent all the information it has about the state of the network.

Parameters: net_size : int (optional, default: 1) The total number of edges in the network. AgentFactory : class (optional, default: InfoAgent) The class of agents that arrive from outside the network. qbuffer : int (optional, default: infty) The maximum number of agents that can be waiting to be serviced. **kwargs : Extra parameters to pass to LossQueue.
class queueing_tool.queues.ResourceQueue(num_servers=10, AgentFactory=ResourceAgent, qbuffer=0, **kwargs)[source]

Bases: queueing_tool.queues.queue_servers.LossQueue

An queue designed to interact with the ResourceAgent class.

If a ResourceAgent does not have a resource already it will take a resource from this queue when it departs. It does this by reducing the number of servers here by one. When a ResourceAgent arrives to this queue with a resource, it adds one to the number of servers here. The ResourceAgent is then deleted.

Attributes

 max_servers (int) The maximum number of servers that can be here. This is a soft max, and it is only used to keep track of how often the queue will be overflowing with resources. over_max (int) The number of times an agent has deposited a resource here when the number of servers was at max_servers. kwargs Any arguments to pass to LossQueue.
next_event()[source]

Simulates the queue forward one event.

This method behaves identically to a LossQueue if the arriving/departing agent is anything other than a ResourceAgent. The differences are;

Arriving:

Departing:

• If the ResourceAgent does not have a resource, then num_servers decreases by one and the agent then has a resource.

Use simulate() for simulating instead.

class queueing_tool.queues.NullQueue(*args, **kwargs)[source]

Bases: queueing_tool.queues.queue_servers.QueueServer

A terminal queue.

A queue that is used by the QueueNetwork class to represent agents leaving the network. Since the NullQueue is used to represent agents leaving the network, all agents that arrive to this queue are deleted.

This class can collect data on agents, but only collects each agent’s arrival time. With the exception of next_event_description, number_queued, and current_color, all functions have been replaced with pass. The methods next_event_description() and number_queued() will always return 0.

## Agents¶

class queueing_tool.queues.Agent(agent_id=(0, 0), **kwargs)[source]

The base class for an agent.

Agents are the objects that move throughout the network. Agents are instantiated by a queue, and once serviced the Agent moves on to another queue in the network. Each Agent decides where in the network it wants to arrive at next but choosing amongst its options randomly. The probabilities are specified in QueueNetwork's transition matrix. See set_transitions() for changing the routing probabilities.

Parameters: agent_id : tuple (optional, default: (0, 0)) A unique identifier for an agent. Is set automatically by the QueueServer that instantiates the Agent. The first slot is the QueueServer's edge index and the second slot is the Agent's instantiation number for that queue. **kwargs : Unused.

Attributes

 agent_id (tuple) A unique identifier for an agent. blocked (int) Specifies how many times an agent has been blocked by a finite capacity queue.
add_loss(*args, **kwargs)[source]

Adds one to the number of times the agent has been blocked from entering a queue.

desired_destination(network, edge)[source]

Returns the agents next destination given their current location on the network.

An Agent chooses one of the out edges at random. The probability that the Agent will travel along a specific edge is specified in the QueueNetwork's transition matrix.

Parameters: network : QueueNetwork The QueueNetwork where the Agent resides. edge : tuple A 4-tuple indicating which edge this agent is located at. The first two slots indicate the current edge’s source and target vertices, while the third slot indicates this edges edge_index. The last slot indicates the edge type of that edge out : int Returns an the edge index corresponding to the agents next edge to visit in the network.

transitions()
QueueNetwork's method that returns the transition probabilities for each edge in the graph.
queue_action(queue, *args, **kwargs)[source]

A method that acts on the queue the Agent is at. This method is called when the Agent arrives at the queue (where args[0] == 0), when service starts for the Agent (where args[0] == 1), and when the Agent departs from the queue (where args[0] == 2). By default, this method does nothing to the queue, but is here if the Agent class is extended and this method is overwritten.

class queueing_tool.queues.GreedyAgent(agent_id=(0, 0))[source]

Bases: queueing_tool.queues.agents.Agent

An agent that chooses the queue with the shortest line as their next destination.

Notes

If there are any ties, the GreedyAgent chooses the first queue with the shortest line (where the ordering is given by QueueNetwork's out_edges attribute).

desired_destination(network, edge)[source]

Returns the agents next destination given their current location on the network.

GreedyAgents choose their next destination with-in the network by picking the adjacent queue with the fewest number of Agents in the queue.

Parameters: network : QueueNetwork The QueueNetwork where the Agent resides. edge : tuple A 4-tuple indicating which edge this agent is located at. The first two slots indicate the current edge’s source and target vertices, while the third slot indicates this edges edge_index. The last slot indicates the edges edge type. out : int Returns an the edge index corresponding to the agents next edge to visit in the network.
class queueing_tool.queues.InfoAgent(agent_id=(0, 0), net_size=1, **kwargs)[source]

Bases: queueing_tool.queues.agents.Agent

An agent that carries information about the QueueNetwork around.

This agent is designed to work with the InfoQueue. It collects load data (utilization rate, and the number of agents waiting to be served) from each queue that it visits.

Parameters: agent_id : tuple (optional, default: (0, 0)) A unique identifier for an agent. Is set automatically by the queue that instantiates the agent. The first slot is queues edge index and the second slot is specifies the instantiation number for that queue. net_size : int (optional, default: 1) The number of edges in the network. **kwargs : Any arguments to pass to Agent.
class queueing_tool.queues.ResourceAgent(agent_id=(0, 0))[source]

Bases: queueing_tool.queues.agents.Agent

An agent designed to interact with the ResourceQueue class.

When an ResourceAgent departs from a ResourceQueue, they take a resource from the queue if the agent does not have a resource yet. It does this by reducing the number of servers at that queue by one. When a ResourceAgent with a resource arrives at a ResourceQueue, the ResourceAgent adds a resource to that queue by increasing the number of servers there by one; the ResourceAgent is then deleted.

queue_action(queue, *args, **kwargs)[source]

Function that specifies the interaction with a ResourceQueue upon departure.

When departuring from a ResourceQueue (or a QueueServer), this method is called. If the agent does not already have a resource then it decrements the number of servers at ResourceQueue by one. Note that this only applies to ResourceQueue's.

Parameters: queue : QueueServer The instance of the queue that the ResourceAgent will interact with.

## Queueing Functions¶

queueing_tool.queues.poisson_random_measure(t, rate, rate_max)[source]

A function that returns the arrival time of the next arrival for a Poisson random measure.

Parameters: t : float The start time from which to simulate the next arrival time. rate : function The intensity function for the measure, where rate(t) is the expected arrival rate at time t. rate_max : float The maximum value of the rate function. out : float The time of the next arrival.

Notes

This function returns the time of the next arrival, where the distribution of the number of arrivals between times $$t$$ and $$t+s$$ is Poisson with mean

$\int_{t}^{t+s} dx \, r(x)$

where $$r(t)$$ is the supplied rate function. This function can only simulate processes that have bounded intensity functions. See chapter 6 of [R12] for more on the mathematics behind Poisson random measures; the book’s publisher, Springer, has that chapter available online for free at (pdf).

A Poisson random measure is sometimes called a non-homogeneous Poisson process. A Poisson process is a special type of Poisson random measure.

References

 [R12] (1, 2) Cinlar, Erhan. Probability and stochastics. Graduate Texts in Mathematics. Vol. 261. Springer, New York, 2011. DOI: 10.1007/978-0-387-87859-1

Examples

Suppose you wanted to model the arrival process as a Poisson random measure with rate function $$r(t) = 2 + \sin( 2\pi t)$$. Then you could do so as follows:

>>> import queueing_tool as qt
>>> import numpy as np
>>> np.random.seed(10)
>>> rate  = lambda t: 2 + np.sin(2 * np.pi * t)
>>> arr_f = lambda t: qt.poisson_random_measure(t, rate, 3)
>>> arr_f(1)
1.491...

format: plain


text:
# Likelihood ratio minimal sufficient

Consider a family of density functions $f(x|\theta)$ where the parameter space for $\theta$ is finite, that is, $\theta \in \{\theta_1, \cdots, \theta_p\}$. Assume that $\theta_p$ is such that $f(x|\theta_p) > 0$ for all $x$ on the support. Now consider the statistic $T(\mathbf{X}) = (T_1(\mathbf{X}), \cdots, T_p(\mathbf{X})) = \left(\frac{f(\mathbf{X}|\theta_1)}{f(\mathbf{X}|\theta_p)}, \cdots, \frac{f(\mathbf{X}|\theta_p)}{f(\mathbf{X}|\theta_p)} \right)$. Show that it is a minimal sufficient statistic of $\theta$.

I'm assuming I need to somehow apply the factorization theorem here to first show it is sufficient, then somehow show it is minimal. Is that the right approach? If not, how would I start?

Consider $f(x|\theta)$ for $\theta \in \{\theta_1, \cdots, \theta_p\}$. It can be written as \begin{align*} f(x|\theta)&=\frac{f(x|\theta)}{f(x|\theta_p)}\times f(x|\theta_p)\\ &=f(x|\theta_p)\,\exp\{\log[{f(x|\theta)}\big/{f(x|\theta_p)}]\} \end{align*} Since $\theta \in \{\theta_1, \cdots, \theta_p\}$, $\theta$ is one of the $\theta_i$'s, meaning $$\sum_{i=1}^p \mathbb{I}_{\theta=\theta_i}=\sum_{i=1}^p \mathbb{I}_{\theta_i}(\theta)=1$$ Thus $$\log[{f(x|\theta)}\big/{f(x|\theta_p)}]=\sum_{i=1}^p \mathbb{I}_{\theta_i}(\theta)\log[{f(x|\theta_i)}\big/{f(x|\theta_p)}]=\sum_{i=1}^p \mathbb{I}_{\theta_i}(\theta)\log[T_i(x)]$$and $$f(x|\theta)=\underbrace{f(x|\theta_p)}_{h(x)}\,\exp\underbrace{\left\{\sum_{i=1}^p \mathbb{I}_{\theta_i}(\theta)\log[T_i(x)]\right\}}_{R(\theta)^\text{T}S(x)}$$As a consequence, the density $f(x|\theta)$ belongs to an exponential family with natural parameter $R(\theta)$ and sufficient statistic $S(x)$. Since the components of $R(\theta)$ are linearly independent, the statistic $S(x)$ [and hence the statistic $T(x)$] are minimal. I remember seeing something like that in a paper by Don Fraser.


text:
6. Process or Product Monitoring and Control
6.1. Introduction

## What is Process Capability?

Process capability compares the output of an in-control process to the specification limits by using capability indices. The comparison is made by forming the ratio of the spread between the process specifications (the specification "width") to the spread of the process values, as measured by 6 process standard deviation units (the process "width").

Process Capability Indices

A process capability index uses both the process variability and the process specifications to determine whether the process is "capable" We are often required to compare the output of a stable process with the process specifications and make a statement about how well the process meets specification.  To do this we compare the natural variability of a stable process with the process specification limits.

A process where almost all the measurements fall inside the specification limits is a capable process. This can be represented pictorially by the plot below:

There are several statistics that can be used to measure the capability of a process:  $$C_p$$, $$C_{pk}$$, and $$C_{pm}$$.

Most capability indices estimates are valid only if the sample size used is "large enough". Large enough is generally thought to be about 50 independent data values.

The $$C_p$$, $$C_{pk}$$, and $$C_{pm}$$ statistics assume that the population of data values is normally distributed. Assuming a two-sided specification, if $$\mu$$ and $$\sigma$$ are the mean and standard deviation, respectively, of the normal data and $$\mbox{USL}$$, $$\mbox{LSL}$$, and $$T$$ are the upper and lower specification limits and the target value, respectively, then the population capability indices are defined as follows.

Definitions of various process capability indices $$C_{p} = \frac{\mbox{USL} - \mbox{LSL}} {6\sigma}$$

$$C_{pk} = \min{\left[ \frac{\mbox{USL} - \mu} {3\sigma}, \frac{\mu - \mbox{LSL}} {3\sigma}\right]}$$

$$C_{pm} = \frac{\mbox{USL} - \mbox{LSL}} {6\sqrt{\sigma^2 + (\mu - T)^2}}$$

Sample estimates of capability indices Sample estimators for these indices are given below. (Estimators are indicated with a "hat" over them).

$$\hat{C}_{p} = \frac{\mbox{USL} - \mbox{LSL}} {6s}$$

$$\hat{C}_{pk} = \min{\left[ \frac{\mbox{USL} - \bar{x}} {3s}, \frac{\bar{x} - \mbox{LSL}} {3s}\right]}$$

$$\hat{C}_{pm} = \frac{\mbox{USL} - \mbox{LSL}} {6\sqrt{s^2 + (\bar{x} - T)^2}}$$

The estimator for $$C_{pk}$$ can also be expressed as $$C_{pk} = C_p(1-k)$$, where $$k$$ is a scaled distance between the midpoint of the specification range, $$m$$, and the process mean, $$\mu$$.

Denote the midpoint of the specification range by $$m = (\mbox{USL} + \mbox{LSL})/2$$. The distance between the process mean, $$\mu$$, and the optimum, which is $$m$$, is $$\mu - m$$, where $$m \le \mu \le \mbox{LSL}$$. The scaled distance is $$k = \frac{|m - \mu|} {(\mbox{USL} - \mbox{LSL})/2}, \;\;\;\;\;\; 0 \le k \le 1 \, .$$ (The absolute sign takes care of the case when $$\mbox{LSL} \le \mu \le m$$). To determine the estimated value, $$\hat{k}$$, we estimate $$\mu$$ by $$\bar{x}$$. Note that $$\bar{x} \le \mbox{USL}$$.

The estimator for the $$C_p$$ index, adjusted by the $$k$$ factor, is $$\hat{C}_{pk} = \hat{C}_{p}(1 - \hat{k}) \, .$$ Since $$0 \le k \le 1$$, it follows that $$\hat{C}_{pk} \le \hat{C}_{p}$$.

Plot showing $$C_p$$ for varying process widths To get an idea of the value of the $$C_p$$ statistic for varying process widths, consider the following plot.

This can be expressed numerically by the table below:

Translating capability into "rejects"
 $$\mbox{USL} - \mbox{LSL}$$ $$6 \sigma$$ $$8 \sigma$$ $$10 \sigma$$ $$12 \sigma$$ $$C_p$$ 1.00 1.33 1.66 2.00 Rejects 0.27 % 64 ppm 0.6 ppm 2 ppb % of spec used 100 75 60 50

where ppm = parts per million and ppb = parts per billion. Note that the reject figures are based on the assumption that the distribution is centered at $$\mu$$.

We have discussed the situation with two spec. limits, the $$\mbox{USL}$$ and $$\mbox{LSL}$$. This is known as the bilateral or two-sided case. There are many cases where only the lower or upper specifications are used. Using one spec limit is called unilateral or one-sided. The corresponding capability indices are

One-sided specifications and the corresponding capability indices
$$C_{pu} = \frac{\mbox{allowable upper spread}} {\mbox{actual upper spread}} = \frac{\mbox{USL} - \mu} {3\sigma}$$
and
$$C_{pl} = \frac{\mbox{allowable lower spread}} {\mbox{actual lower spread}} = \frac{\mu - \mbox{LSL}} {3\sigma} \, ,$$
where $$\mu$$ and $$\sigma$$ are the process mean and standard deviation, respectively.

Estimators of $$C_{pu}$$ and $$C_{pl}$$ are obtained by replacing $$\mu$$ and $$\sigma$$ by $$\bar{x}$$ and $$s$$, respectively. The following relationship holds $$C_p = \frac{C_{pu} + C_{pl}}{2} \, .$$ This can be represented pictorially by

Note that we also can write:

$$C_{pk} = \mbox{min}(C_{pl}, \, C_{pu}) \, .$$

Confidence Limits For Capability Indices
Confidence intervals for indices Assuming normally distributed process data, the distribution of the sample $$\hat{C}_p$$ follows from a Chi-square distribution and $$\hat{C}_{pu}$$ and $$\hat{C}_{pl}$$ have distributions related to the non-central t distribution. Fortunately, approximate confidence limits related to the normal distribution have been derived. Various approximations to the distribution of $$\hat{C}_{pk}$$ have been proposed, including those given by Bissell (1990), and we will use a normal approximation.

The resulting formulas for $$100(1-\alpha) \%$$ confidence limits are given below.

Confidence Limits for $$C_p$$ are $$Pr\{\hat{C}_{p}(L_1) \le C_p \le \hat{C}_{p}(L_2)\} = 1 - \alpha \, ,$$ where $$\begin{eqnarray} L_1 & = & \sqrt{\frac{\chi^2_{\alpha/2, \, \nu}}{\nu}} \, , \\ & & \\ L_2 & = & \sqrt{\frac{\chi^2_{1-\alpha/2, \, \nu}}{\nu}} \, , \end{eqnarray}$$ and $$\nu =$$ degrees of freedom.

Confidence Intervals for $$C_{pu}$$ and $$C_{pl}$$ Approximate $$100(1-\alpha)$$ % confidence limits for $$C_{pu}$$ with sample size $$n$$ are: $$C_{pu}(lower) = \hat{C}_{pu} - z_{1-\beta}\sqrt{\frac{1}{9n} + \frac{\hat{C}_{pu}^{2}}{2(n-1)}}$$ and

$$C_{pu}(upper) = \hat{C}_{pu} + z_{1-\alpha}\sqrt{\frac{1}{9n} + \frac{\hat{C}_{pu}^{2}}{2(n-1)}} \, ,$$ with $$z$$ denoting the percent point function of the standard normal distribution. If $$\beta$$ is not known, set it to $$\alpha$$.

Limits for $$C_{pl}$$ are obtained by replacing $$\hat{C}_{pu}$$ by $$\hat{C}_{pl}$$.

Confidence Interval for $$C_{pk}$$ Zhang et al. (1990) derived the exact variance for the estimator of $$C_{pk}$$ as well as an approximation for large $$n$$. The reference paper is Zhang, Stenback and Wardrop (1990), "Interval Estimation of the process capability index," Communications in Statistics: Theory and Methods, 19(21), 4455-4470.

The variance is obtained as follows.

Let

$$c = \sqrt{n}\left[\mu - (\mbox{USL} + \mbox{LSL})/2\right]\sigma$$ $$d = (\mbox{USL} - \mbox{LSL})/\sigma$$ $$\Phi(-c) = \int_{-inf}^{-c}{\frac{1}{\sqrt{2\pi}}\exp{-5z^2}dz} \, .$$
Then
$$Var(\hat{C}_{pk})$$ $$= (d^2/36)(n-1)(n-3)$$ $$-(d/9\sqrt{n})(n-1)(n-3)\{\sqrt{2\pi}\exp{(-c^2/2)} + c[1 - 2\Phi(-c)]\}$$ $$+[(1/9)(n-1)/(n(n-3))](1+c^2)$$ $$-[(n-1)/(72n)]\{\frac{\Gamma((n-2)/2)}{\Gamma((n-1)/2)}\}^2$$ $$*\{d\sqrt{n} - 2\sqrt{2\pi}\exp{(-c^2/2)} - 2c[1 - 2\Phi(-c)]\}^2 \, .$$
Their approximation is given by:
$$Var(\hat{C}_{pk}) = \frac{n-1}{n-3} - 0.5\{\frac{\Gamma((n-2)/2)}{\Gamma((n-1)/2)}\}^2 \, ,$$
where
$$n \ge 25, \,\,\,\,\,\, 0.75 \le C_{pk} \le 4, \,\,\,\,\,\, |c| \le 100, \,\,\,\,\,\, \mbox{ and } \,\,\,\,\,\, d \le 24 \, .$$
The following approximation is commonly used in practice $$C_{pk} = \hat{C}_{pk} \pm z_{1-\alpha/2}\sqrt{\frac{1}{9n} + \frac{\hat{C}_{pk}^{2}}{2(n-1)}} \, .$$ It is important to note that the sample size should be at least 25 before these approximations are valid. In general, however, we need $$n \ge 100$$ for capability studies. Another point to observe is that variations are not negligible due to the randomness of capability indices.
Capability Index Example
An example For a certain process the $$\mbox{USL} = 20$$ and the $$\mbox{LSL} = 8$$. The observed process average, $$\bar{x} \ge 16$$, and the standard deviation, $$s = 2$$. From this we obtain $$\hat{C}_{p} = \frac{\mbox{USL} - \mbox{LSL}} {6s} = \frac{20 - 8} {6(2)} = 1.0 \, .$$ This means that the process is capable as long as it is located at the midpoint, $$m = (\mbox{USL} + \mbox{LSL})/2 = 14$$.

But it doesn't, since $$\bar{x} \ge 16$$. The $$\hat{k}$$ factor is found by $$\hat{k} = \frac{|m - \bar{x}|} {(\mbox{USL} - \mbox{LSL})/2} = \frac{2} {6} = 0.3333$$ and $$\hat{C}_{pk} = \hat{C}_{p}(1-\hat{k}) = 0.6667 \, .$$ We would like to have $$\hat{C}_{pk}$$ at least 1.0, so this is not a good process. If possible, reduce the variability or/and center the process. We can compute the $$\hat{C}_{pu}$$ and $$\hat{C}_{pl}$$ using $$\hat{C}_{pu} = \frac{\mbox{USL} - \bar{x}} {3s} = \frac{20 - 16} {3(2)} = 0.6667$$ and $$\hat{C}_{pl} = \frac{\bar{x} - \mbox{LSL}} {3s} = \frac{16 - 8} {3(2)} = 1.3333 \, .$$ From this we see that the $$\hat{C}_{pu}$$, which is the smallest of the above indices, is 0.6667. Note that the formula $$\hat{C}_{pk} = \hat{C}_{p}(1 - \hat{k})$$ is the algebraic equivalent of the $$\mbox{min}(\hat{C}_{pu}, \, \hat{C}_{pl})$$ definition.

What happens if the process is not approximately normally distributed?
What you can do with non-normal data The indices that we considered thus far are based on normality of the process distribution. This poses a problem when the process distribution is not normal. Without going into the specifics, we can list some remedies.
1. Transform the data so that they become approximately normal. A popular transformation is the Box-Cox transformation

2. Use or develop another set of indices, that apply to nonnormal distributions. Non-parameteric versions (Pearn, Tai, Hsiao, and Ao (2014) and Chen and Ding (2001)) of the $$C_{p}$$, $$C_{pk}$$, and $$C_{pm}$$ capability indices are denoted by $$C_{np}$$, $$C_{npk}$$, and $$C_{npm}$$. Estimators for these non-parameteric capability indices are calculated by

$$\hat{C}_{np} = \frac{\mbox{USL} - \mbox{LSL}} {p(0.99865) - p(0.00135)}$$

$$\hat{C}_{npk} = \frac{\mbox{min}\left[ \mbox{USL} - median, median - \mbox{LSL} \right] } {(p(0.99865) - p(0.00135))/2 }$$

$$\hat{C}_{npm} = \frac{\mbox{USL} - \mbox{LSL}} {6 \sqrt{\left( \frac{p(0.99865) - p(0.00135)}{6} \right) ^2 + (median - \mbox{T})^2}}$$

where $$p(0.99855)$$ is the 99.865th percentile of the data and $$p(0.00135)$$ is the 0.135th percentile of the data. The use of these percentiles is justified to mimic the coverage of ±3 standard deviations for the normal distribution. Note that some sources may use 99% coverage. For example, the $$C_{npk}$$ statistic may be given as

$$\hat{C}_{npk} = \mbox{min}\left[\frac{\mbox{USL} - median} {p(0.995) - median}, \frac{median - \mbox{LSL}}{median - p(0.005)} \right]$$

where $$p(0.995)$$ is the 99.5th percentile of the data and $$p(0.005)$$ is the 0.5th percentile of the data.

For additional information on nonnormal distributions, see Johnson and Kotz (1993).

There is, of course, much more that can be said about the case of nonnormal data. However, if a Box-Cox transformation can be successfully performed, one is encouraged to use it.


text:
# Algebraic Geometry in East Asia: Hanoi 2005

###### Kazuhiro Konno and Viet Nguyen-Khac, editors
Publisher:
Mathematical Society of Japan/American Mathematical Society
Publication Date:
2008
Number of Pages:
344
Format:
Hardcover
Series:
Advanced Studies in Pure Mathematics 50
Price:
53.00
ISBN:
9784931469457
Category:
Proceedings
We do not plan to review this book.
• E. A. Bartolo, J. I. Cogolludo, and H. Tokunaga -- A survey on Zariski pairs
• K. Saito -- Towards a categorical construction of Lie algebras
• M. Kuwata and T. Shioda -- Elliptic parameters and defining equations for elliptic fibrations on a Kummer surface
• J. Hong and J.-M. Hwang -- Characterization of the rational homogeneous space associated to a long simple root by its variety of minimal rational tangents
• S. Ishii -- Maximal divisorial sets in arc spaces
• V. A. Iskovskikh -- Two non-conjugate embeddings of $S_3\times \mathbb{Z}_2$ into the Cremona group II
• C. Keem and A. Ohbuchi -- On the Castelnuovo-Severi inequality for a double covering
• G. Jiang, J. Yu, and J. Zhang -- Poincaré polynomial of a class of signed complete graphic arrangements
• I. Shimada -- Singularities of dual varieties in characteristic 2
• V. Nguyen-Khac and T. Shioda -- On the Castelnuovo-Weil lattices, I


text:
GMAT Question of the Day - Daily to your Mailbox; hard ones only

 It is currently 23 Oct 2018, 07:45

### GMAT Club Daily Prep

#### Thank you for using the timer - this advanced tool can estimate your performance and suggest more practice questions. We have subscribed you to Daily Prep Questions via email.

Customized
for You

we will pick new questions that match your level based on your Timer History

Track

every week, we’ll send you an estimated GMAT score based on your performance

Practice
Pays

we will pick new questions that match your level based on your Timer History

# If P, Q, R, and S are positive integers, and P/Q = R/S, is R

 new topic post reply Question banks Downloads My Bookmarks Reviews Important topics
Author Message
TAGS:

### Hide Tags

Director
Joined: 07 Jun 2004
Posts: 603
Location: PA
If P, Q, R, and S are positive integers, and P/Q = R/S, is R  [#permalink]

### Show Tags

01 Feb 2011, 11:01
2
9
00:00

Difficulty:

65% (hard)

Question Stats:

57% (01:17) correct 43% (01:22) wrong based on 327 sessions

### HideShow timer Statistics

If P, Q, R, and S are positive integers, and P/Q = R/S, is R divisible by 5?

(1) P is divisible by 140

(2) Q = 7^x, where x is a positive integer

_________________

If the Q jogged your mind do Kudos me : )

Math Expert
Joined: 02 Sep 2009
Posts: 50058
Re: Ratio Tough one  [#permalink]

### Show Tags

01 Feb 2011, 11:23
3
rxs0005 wrote:
If P, Q, R, and S are positive integers, and P / Q = R / S, is R divisible by 5 ?

(1) P is divisible by 140

(2) Q = 7^x , where x is a positive integer

Not convinced by the OA

If P, Q, R, and S are positive integers, and P/Q=R/S, is R divisible by 5?

Given: $$R=\frac{PS}{Q}$$

(1) P is divisible by 140 --> P is multiple of 5 --> now, if all 5-s from P and S (if there are any) are reduced by 5-s in Q then the answer will be No (for example P=140=5*28, S=1 and Q=5) but if the sum of powers of 5 in P and S is higher than the power of 5 in Q then not all 5-s will be reduced and R will be a multiple of 5 (for example P=140=5*28, S=1 and Q=1 or P=140*5=5^2*28, S=1 and Q=5). Not sufficient.

(2) Q= 7^x, where x is a positive integer. Clearly insufficient.

(1)+(2) Q is not a multiple of 5 at all thus 5-s in P won't be reduced so as $$R=\frac{PS}{Q}=5*integer$$ then R is indeed a multiple of 5. Sufficient.

_________________
Director
Joined: 07 Jun 2004
Posts: 603
Location: PA
Re: Ratio Tough one  [#permalink]

### Show Tags

01 Feb 2011, 14:10
Bunuel thanks

the way i approached this DS was

i see P / Q = R / S as a proportion

after S1 and S2 let us say p / q is

140 / 49 = 2.87

R / S can be any values that can lead to 2.87 so R by itself need not be a multiple of 5

what is the error in my reasoning so i went for E
_________________

If the Q jogged your mind do Kudos me : )

Math Expert
Joined: 02 Sep 2009
Posts: 50058
Re: Ratio Tough one  [#permalink]

### Show Tags

01 Feb 2011, 14:22
rxs0005 wrote:
Bunuel thanks

the way i approached this DS was

i see P / Q = R / S as a proportion

after S1 and S2 let us say p / q is

140 / 49 = 2.87

R / S can be any values that can lead to 2.87 so R by itself need not be a multiple of 5

what is the error in my reasoning so i went for E

First of all 140/49 does not equal to 2.87 it equals to 20/7 (it'll be a recurring decimal). So R/S=20/7 --> R is a multiple of 20 so it's a multiple of 5 too (note that we are told that all variables are positive integers).
_________________
Manager
Joined: 27 Oct 2010
Posts: 124
Re: Ratio Tough one  [#permalink]

### Show Tags

01 Feb 2011, 16:23
(P / Q) * S = R

Stmt 1 says P = 140 * X

(140 * X / Q) * S = R

We do not know anything about Q. So Stmt 1 is insuff.

Stmt 2 says Q can be 7, 49 ... But we do not know anythng abt P. So Stmt 2 is insuff.

Combining both, we know R is +ve integer. So, Q has to be 7 and R is multiple of 5. C
Manager
Joined: 17 Oct 2012
Posts: 50
Re: Ratio Tough one  [#permalink]

### Show Tags

01 Jul 2013, 14:15
Bunuel wrote:
rxs0005 wrote:
If P, Q, R, and S are positive integers, and P / Q = R / S, is R divisible by 5 ?

(1) P is divisible by 140

(2) Q = 7^x , where x is a positive integer

Not convinced by the OA

If P, Q, R, and S are positive integers, and P/Q=R/S, is R divisible by 5?

Given: $$R=\frac{PS}{Q}$$

(1) P is divisible by 140 --> P is multiple of 5 --> now, if all 5-s from P and S (if there are any) are reduced by 5-s in Q then the answer will be No (for example P=140=5*28, S=1 and Q=5) but if the sum of powers of 5 in P and S is higher than the power of 5 in Q then not all 5-s will be reduced and R will be a multiple of 5 (for example P=140=5*28, S=1 and Q=1 or P=140*5=5^2*28, S=1 and Q=5). Not sufficient.

(2) Q= 7^x, where x is a positive integer. Clearly insufficient.

(1)+(2) Q is not a multiple of 5 at all thus 5-s in P won't be reduced so as $$R=\frac{PS}{Q}=5*integer$$ then R is indeed a multiple of 5. Sufficient.

Q can also be 35..so then the 5 would also be reduced. So how do you know that R is then still a multiple of 5? what am I missing?
Math Expert
Joined: 02 Sep 2009
Posts: 50058
Re: Ratio Tough one  [#permalink]

### Show Tags

01 Jul 2013, 14:20
BankerRUS wrote:
Bunuel wrote:
rxs0005 wrote:
If P, Q, R, and S are positive integers, and P / Q = R / S, is R divisible by 5 ?

(1) P is divisible by 140

(2) Q = 7^x , where x is a positive integer

Not convinced by the OA

If P, Q, R, and S are positive integers, and P/Q=R/S, is R divisible by 5?

Given: $$R=\frac{PS}{Q}$$

(1) P is divisible by 140 --> P is multiple of 5 --> now, if all 5-s from P and S (if there are any) are reduced by 5-s in Q then the answer will be No (for example P=140=5*28, S=1 and Q=5) but if the sum of powers of 5 in P and S is higher than the power of 5 in Q then not all 5-s will be reduced and R will be a multiple of 5 (for example P=140=5*28, S=1 and Q=1 or P=140*5=5^2*28, S=1 and Q=5). Not sufficient.

(2) Q= 7^x, where x is a positive integer. Clearly insufficient.

(1)+(2) Q is not a multiple of 5 at all thus 5-s in P won't be reduced so as $$R=\frac{PS}{Q}=5*integer$$ then R is indeed a multiple of 5. Sufficient.

Q can also be 35..so then the 5 would also be reduced. So how do you know that R is then still a multiple of 5? what am I missing?

Q cannot be 35 or any other multiple of 5, since it equals to $$7^{positive \ integer}$$.

Hope it's clear.
_________________
SVP
Joined: 06 Sep 2013
Posts: 1765
Concentration: Finance
Re: Ratio Tough one  [#permalink]

### Show Tags

30 Jan 2014, 17:43
Bunuel wrote:
rxs0005 wrote:
If P, Q, R, and S are positive integers, and P / Q = R / S, is R divisible by 5 ?

(1) P is divisible by 140

(2) Q = 7^x , where x is a positive integer

Not convinced by the OA

If P, Q, R, and S are positive integers, and P/Q=R/S, is R divisible by 5?

Given: $$R=\frac{PS}{Q}$$

(1) P is divisible by 140 --> P is multiple of 5 --> now, if all 5-s from P and S (if there are any) are reduced by 5-s in Q then the answer will be No (for example P=140=5*28, S=1 and Q=5) but if the sum of powers of 5 in P and S is higher than the power of 5 in Q then not all 5-s will be reduced and R will be a multiple of 5 (for example P=140=5*28, S=1 and Q=1 or P=140*5=5^2*28, S=1 and Q=5). Not sufficient.

(2) Q= 7^x, where x is a positive integer. Clearly insufficient.

(1)+(2) Q is not a multiple of 5 at all thus 5-s in P won't be reduced so as $$R=\frac{PS}{Q}=5*integer$$ then R is indeed a multiple of 5. Sufficient.

Bunuel sorry, I don't quite get it

So we have P,Q,R,S are positive integers and we're trying to figure out whether R = PS/Q is divisible by 5 or if PS / 5Q is an integer right?

So Statement 1

P is divisible by 130, but I don't know nothing about the other two only that they are integers

Not sufficients

Statement 2

Q= 7^X

Clearly Insuff

Both together

I have the quesiton: is 140S / 5Q an integer where Q = 7^X

Well x could be anything and hence not sufficient

E

But I'm pretty sure there's something I'm missing, would anybody please clarify what's wrong with this line of reasoning?

Cheers
J
Veritas Prep GMAT Instructor
Joined: 16 Oct 2010
Posts: 8418
Location: Pune, India
Re: Ratio Tough one  [#permalink]

### Show Tags

30 Jan 2014, 21:50
1
jlgdr wrote:
Both together

I have the quesiton: is 140S / 5Q an integer where Q = 7^X

Well x could be anything and hence not sufficient

E

But I'm pretty sure there's something I'm missing, would anybody please clarify what's wrong with this line of reasoning?

Cheers
J

Yeah, the concept here is quite basic but we often overlook it.

Think about it: Is $$3^5 * 7^6 * 11^3$$ divisible by 13?
The answer is simply 'No'.

For the numerator to be divisible by the denominator, the denominator MUST BE a factor of the numerator.
3^5 is only five 3s.
7^6 is only six 7s.
11^3 is only three 11s.
In the entire numerator, there is no 13 so the numerator is not divisible by 13.

On the other hand, is $$3^5 * 7^6 * 11^3 * 13$$ divisible by 13? Yes, it is. 13 gets cancelled and the quotient will be $$3^5 * 7^6 * 11^3$$.

Is 2^X divisible by 3? No. No matter what X is, you will only have X number of 2s in the numerator and will never have a 3. So this will not be divisible by 3.

On the same lines, in this question,

Given that $$R = \frac{(140a)*S}{7^X}$$ where R is an integer.
$$R = \frac{2^2 * 5*7*a*S}{7^X}$$

So whatever X is, 7^X will get cancelled out by the numerator and we will be left with something. That something will include 5 since only 7s will be cancelled out from the numerator. Hence R is divisible by 5.
_________________

Karishma
Veritas Prep GMAT Instructor

Learn more about how Veritas Prep can help you achieve a great GMAT score by checking out their GMAT Prep Options >

GMAT self-study has never been more personalized or more fun. Try ORION Free!

Veritas Prep GMAT Instructor
Joined: 16 Oct 2010
Posts: 8418
Location: Pune, India
Re: If P, Q, R, and S are positive integers, and P/Q = R/S, is R  [#permalink]

### Show Tags

20 Nov 2014, 21:02
1
VeritasPrepKarishma wrote:
jlgdr wrote:
Both together

I have the quesiton: is 140S / 5Q an integer where Q = 7^X

Well x could be anything and hence not sufficient

E

But I'm pretty sure there's something I'm missing, would anybody please clarify what's wrong with this line of reasoning?

Cheers
J

Yeah, the concept here is quite basic but we often overlook it.

Think about it: Is $$3^5 * 7^6 * 11^3$$ divisible by 13?
The answer is simply 'No'.

For the numerator to be divisible by the denominator, the denominator MUST BE a factor of the numerator.
3^5 is only five 3s.
7^6 is only six 7s.
11^3 is only three 11s.
In the entire numerator, there is no 13 so the numerator is not divisible by 13.

On the other hand, is $$3^5 * 7^6 * 11^3 * 13$$ divisible by 13? Yes, it is. 13 gets cancelled and the quotient will be $$3^5 * 7^6 * 11^3$$.

Is 2^X divisible by 3? No. No matter what X is, you will only have X number of 2s in the numerator and will never have a 3. So this will not be divisible by 3.

On the same lines, in this question,

Given that $$R = \frac{(140a)*S}{7^X}$$ where R is an integer.
$$R = \frac{2^2 * 5*7*a*S}{7^X}$$

So whatever X is, 7^X will get cancelled out by the numerator and we will be left with something. That something will include 5 since only 7s will be cancelled out from the numerator. Hence R is divisible by 5.

Responding to a pm:

"The second statement says that R is multiple of 5 for any x . So why are we combining the two statements ? Could you please help."

From the second statement alone, all we know is that Q is a power of 7. We have no idea about what R will be. Statement 1 tells us that P = 140 i.e. a multiple of 5. Hence we know that P must have 5 as a factor. Hence R will have a factor of 5 too.
_________________

Karishma
Veritas Prep GMAT Instructor

Learn more about how Veritas Prep can help you achieve a great GMAT score by checking out their GMAT Prep Options >

GMAT self-study has never been more personalized or more fun. Try ORION Free!

Senior SC Moderator
Joined: 14 Nov 2016
Posts: 1314
Location: Malaysia
If P, Q, R, and S are positive integers, and P/Q = R/S, is R  [#permalink]

### Show Tags

20 Mar 2017, 22:43
rxs0005 wrote:
If P, Q, R, and S are positive integers, and $$\frac{P}{Q} = \frac{R}{S}$$, is R divisible by 5?

(1) P is divisible by 140

(2)$$Q = 7^x$$, where x is a positive integer

OFFICIAL SOLUTION

Let's begin by analyzing the information given to us in the question:

If P, Q, R, and S are positive integers, and $$\frac{P}{Q} = \frac{R}{S}$$, is R divisible by 5 ?

It is often helpful on the GMAT to rephrase equations so that there are no denominators. We can do this my cross-multiplying as follows:

$$\frac{P}{Q} = \frac{R}{S}$$ → $$PS=RQ$$

Now let's analyze Statement (1) alone: P is divisible by 140.

Most GMAT divisibility problems can be solved by breaking numbers down to their prime factors (this is called a "prime factorization").

The prime factorization of 140 is: $$140=2*2*5*7$$.

Thus, if P is divisible by 140, it is also divisible by all the prime factors of 140. We know that P is divisible by 2 twice, by 5, and by 7. However, this gives us no information about R so Statement (1) is not sufficient to answer the question.

Next, let's analyze Statement (2) alone: $$Q = 7^x$$, where x is a positive integer.

From this, we can see that the prime factorization of Q looks something like this: $$Q=7*7*7......$$ Therefore, we know that 7 is the only prime factor of Q. However, this gives us no information about R so Statement (2) is not sufficient to answer the question.

Finally, let's analyze both statements taken together:

From Statement (1), we know that P has 5 as one of its prime factors. Since 5 is a factor of P and since P is a factor of PS, then by definition, 5 is a factor of PS.

Recall that the question told us that $$PS=RQ$$. From this, we can deduce that PS must have the same factors as QR. Since 5 is a factor of PS, 5 must also be a factor of QR.

From Statement (2), we know that 7 is the only prime factor of Q. Therefore, we know that 5 is NOT a factor of Q. However, we know that 5 must be a factor of QR. The only way this can be the case is if 5 is a factor of R.

Thus, by combining both statements we can answer the question: Is R divisible by 5? Yes, it must be divisible by 5. Since BOTH statements TOGETHER are sufficient, but NEITHER statement ALONE is sufficient, the correct answer is C.
_________________

"Be challenged at EVERY MOMENT."

“Strength doesn’t come from what you can do. It comes from overcoming the things you once thought you couldn’t.”

"Each stage of the journey is crucial to attaining new heights of knowledge."

Rules for posting in verbal forum | Please DO NOT post short answer in your post!

Senior Manager
Joined: 15 Jan 2017
Posts: 363
Re: If P, Q, R, and S are positive integers, and P/Q = R/S, is R  [#permalink]

### Show Tags

04 Nov 2017, 11:56
Did this by plugging values:

1) P/140 = no remainder. So P/Q = no remainder
And then we get PS = RQ --> so PS = R (140) (Lets say that Q is 140). Either way, we don't know anything about R. NS

2) Q =7^x --> cn be 7 to power 1, 2,3..least would be 7 to power 1.
P/7 = R/ S --> PS = RQ, again R is what? NS

1) + 2) --> 140 / 7 (coz P's least value is likely to be 140 and Q's least value is 7).

140/7 = R/S
S(140) = R(7)
S (4x5) = R (cancelling 7 on both sides)Therefore R is divisible by 5.
Ans C

Kudos please, if you found this useful!
Senior Manager
Joined: 19 Oct 2013
Posts: 345
Location: Kuwait
GPA: 3.2
WE: Engineering (Real Estate)
Re: If P, Q, R, and S are positive integers, and P/Q = R/S, is R  [#permalink]

### Show Tags

05 Oct 2018, 16:53
rxs0005 wrote:
If P, Q, R, and S are positive integers, and P/Q = R/S, is R divisible by 5?

(1) P is divisible by 140

(2) Q = 7^x, where x is a positive integer

if we rewrite the equation to be P * S = R * Q

1) P is divisible by 140. P is a multiple of 140

140 * S = R * Q. Let S=1, let R = 140, and let Q = 1 then yes divisible. Let S = 1, let R = 1 and let Q = 140. No not divisible.

Insufficient

2) it provides information on Q only which is not enough to decide.

Combine both now

140 * S = R * $$7^x$$

20 * 7 * S = R * $$7^x$$

P can be 140,280,420 etc.. the 7 will always have a power of 1.

R is divisible by 5 sufficient.

C
Re: If P, Q, R, and S are positive integers, and P/Q = R/S, is R &nbs [#permalink] 05 Oct 2018, 16:53
Display posts from previous: Sort by

# If P, Q, R, and S are positive integers, and P/Q = R/S, is R

 new topic post reply Question banks Downloads My Bookmarks Reviews Important topics

 Powered by phpBB © phpBB Group | Emoji artwork provided by EmojiOne Kindly note that the GMAT® test is a registered trademark of the Graduate Management Admission Council®, and this site has neither been reviewed nor endorsed by GMAC®.


text:
# Ω 2

Personal Blog
Crossposted from the AI Alignment Forum. May contain more technical jargon than usual.

MIRI's paper on robust cooperation in the one-shot prisoner's dilemma (by Patrick LaVictoire and others) models agents which know their opponents' source code through Gödel-Löb provability logic, a modal logic for reasoning about provability in Peano Arithmetic. This framework of "modal agents" has turned out to be a really useful way of reasoning about these agents. Vladimir Slepnev recently proposed reformulating UDT with a halting oracle in terms of provability logic as well, and I agree that this is the right tool for the job. This post is a primer on provability logic and the results about it that we've been using in our work.

# The language

Gödel-Löb provability logic ("GL") is propositional logic plus a modal operator, , which we interpret as "provable". Formulas may contain variables which denote propositions; for example is a formula saying that if the proposition is true, then it's provable that the proposition implies itself. We usually write for the proposition "true" and for the proposition "false".

Some conventions that we've been using: Use small letters (e.g. , ) to refer to propostional variables; use capital letters (e.g. , ) to refer to particular formulas; use , as metavariables ranging over formulas. (The line between "concrete formula" and "metavariable standing in for a formula" isn't hard-and-fast.) When a formula contains propositional variables, list them in parantheses when talking about the formula: e.g., .

The meaning of a closed formula (i.e., a formula without propositional variables) is given by a recursive translation to a sentence of Peano arithmetic: If the modal formula is translated to the arithmetic formula , then is translated to the arithmetic formula stating "the formula is provable in PA". (Propositional connectives are translated in the obvious way, e.g. is translated to .)

In practice, instead of making this translation explicit, we just abbreviate " is provable in PA" as in formulas of arithmetic, and leave it to the context to disambiguate whether we're talking about a modal or an arithmetic formula. Because of this, we may sometimes write instead of to emphasize the Gödel quotations in the arithmetic version of the formula.

# Soundness and completeness

The axioms and inference rules of GL can be stated in the usual style of a modal logic, but in practice, two basic results about GL provide a much more convenient way to reason about it:

• The soundness theorem states that if a formula is provable in GL, then for any closed formulas in the language of arithmetic, is provable in PA.
• The completeness theorem is the exact converse: It states that if is a formula of provability logic, and if for any closed formulas in the language of arithmetic, is provable in PA, then is provable in GL.

In summary:

This means that we can argue that something is provable in GL by arguing that the analogous thing is provable in PA. For example, Löb's theorem states that if , then . This implies that the analogous statement holds in GL: Suppose that . Then by soundness, for all , and hence by Löb, . But by completess, this implies .

Similarly, implies , again because the analogous statement holds about PA.

As a matter of fact, both of these happen to be an inference rules of GL. But the point is that you don't need to memorize the axioms and inference rules of GL in order to use it; it's sufficient to know about its soundness and completeness.

# Substitution of equivalent formulas

Despite the above, there is one important result about GL that is not obvious from soundness and completeness: If GL proves two formulas and equivalent, then you can substitute for in any other formula, even inside boxes; in other words, in this case, GL will prove that is equivalent to , for every formula .

# Fixed points

The other really important results about GL are the existence and uniqueness of fixed points.

We say that a formula is modalized in if all occurrences of in are inside boxes. We say that is fully modalized if it is modalized in each . (We don't need the latter notion in the rest of this post, but it's frequently used in applications.)

Suppose that is modalized in . Then there is a formula which is a fixed point of in the sense that Moreover, there's a computer program that computes given ; and if is modalized in , then it is modalized in as well.

More generally, this holds for multiple parameters and multiple formulas , . In that case, we can find formulas such that for every , GL proves that is equivalent to

Moreover, it can be shown that these fixed points are unique---not in the sense that there is only one set of formulas satisfying the above condition, of course (if works, so does : see the rule about substitution of equivalent formulas), but in the sense that if is a solution and is also a solution, then , .

This is true not only about solutions that can be written in the language of provability logic, but for any solution in the language of arithmetic: Suppose that , , and are all closed formulas of arithmetic, such that for , PA proves and . Then , for .

# Decidability

Provability in GL turns out to be decidable, though it's PSPACE-complete, which sounds pretty bad, but perhaps the formulas we're interested in are mostly so short that it doesn't matter---I don't know. In the case of modal agents, Mihaly and Marcello wrote program which computes what two such agents do against each other, and it was efficient enough that we were able to use it to verify the examples in the paper. I don't know whether the techniques would generalize to the application to UDT.

If you want to go dig deeper, you may want to consult the Stanford Encyclopedia of Philosophy entry on provability logic or Per Lindström's excellent article "Provability logic---a short introduction" (Theoria, 62(1-2):19--61, 1996). Gated copy.

Some of the results claimed here aren't in Lindström, though they follow straight-forwardly from what is there; I'll later add the proofs in comments. In the meantime, some of the additional stuff can be found in the modal agents paper.

# Ω 2

New Comment

Thread for proofs of results claimed above (not limited to stuff not found in Lindström); contributions appreciated. Stuff not in Lindström includes the uniqueness of arithmetic fixed points in PA (found in the modal agents paper), and I think the version of the fixed point theorem with more than one (the latter should be provable by iterated application of the fixed point theorem for a single ).

Generalized fixed point theorem:

Suppose that are modal sentences such that is modalized in (possibly containing sentence letters other than ).

Then there exists in which no appears such that .

We will prove it by induction.

For the base step, we know by the fixed point theorem that there is such that

Now suppose that for we have such that .

By the second substitution theorem, . Therefore we have that .

If we iterate the replacements, we finally end up with .

Again by the fixed point theorem, there is such that .

But as before, by the second substitution theorem, .

Let stand for , and by combining the previous lines we find that .

By Goldfarb's lemma, we do not need to check the other direction, so and the proof is finished

An immediate consequence of the theorem is that for those fixed points and every , .

Indeed, since is closed under substitution, we can make the change for in the theorem to get that .

Since the righthand side is trivially a theorem of , we get the desired result.

One remark: the proof is wholly constructive. You can iterate the construction of fixed point following the procedure implied by the construction of the to compute fixed points.

Uniqueness of arithmetic fixed points:

Notation:

Let be a fixed point on of ; that is, .

Suppose is such that . Then by the first substitution theorem, for every formula . If , then , from which it follows that .

Conversely, if and are fixed points, then , so since is closed under substitution, . Since , it follows that .

(Taken from The Logic of Provability, by G. Boolos.)


text:
# csafe

## Evaluation and comparison of methods for forensic glass source conclusions

Float glass, a common type of glass used in windows and doors, can be important evidence in the investigation of a crime. If fragments are optically indistinguishable, they may be distinguishable in their chemical compositions, which can be measured …

## Fitting a Random Forest the tidymodels way

An overview of the tidymodels workflow.


text:
# Bipyramid

For Dipyramid, see mountain and Dipyramid (Alaska).
Set of regular right bipyramids

(Example hexagonal form)
Coxeter diagram
Schläfli symbol { } + {n}
Faces 2n triangles
Edges 3n
Vertices 2 + n
Face configuration V4.4.n
Symmetry group Dnh, [n,2], (*n22), order 4n
Rotation group Dn, [n,2]+, (n22), order 2n
Dual polyhedron n-gonal prism
Properties convex, face-transitive
Net
A bipyramid made with straws and elastics. An extra axial straw is added which doesn't exist in the simple polyhedron

An n-gonal bipyramid or dipyramid is a polyhedron formed by joining an n-gonal pyramid and its mirror image base-to-base. An n-gonal bipyramid has 2n triangle faces, 3n edges, and 2 + n vertices.

The referenced n-gon in the name of the bipyramids is not an external face but an internal one, existing on the primary symmetry plane which connects the two pyramid halves.

## Right, oblique and concave bipyramids

A right bipyramid has two points above and below the centroid of its base. Nonright bipyramids are called oblique bipyramids. A regular bipyramid has a regular polygon internal face and is usually implied to be a right bipyramid. A right bipyramid can be represented as { } + P for internal polygon P, and a regular n-bipyramid { } + {n}.

A concave bipyramid has a concave interior polygon.

The face-transitive regular bipyramids are the dual polyhedra of the uniform prisms and will generally have isosceles triangle faces.

A bipyramid can be projected on a sphere or globe as n equally spaced lines of longitude going from pole to pole, and bisected by a line around the equator.

Bipyramid faces, projected as spherical triangles, represent the fundamental domains in the dihedral symmetry Dnh.

## Volume

The volume of a bipyramid is V =2/3Bh where B is the area of the base and h the height from the base to the apex. This works for any location of the apex, provided that h is measured as the perpendicular distance from the plane which contains the base.

The volume of a bipyramid whose base is a regular n-sided polygon with side length s and whose height is h is therefore:

${\displaystyle V={\frac {n}{6}}hs^{2}\cot {\frac {\pi }{n}}.}$

## Equilateral triangle bipyramids

Only three kinds of bipyramids can have all edges of the same length (which implies that all faces are equilateral triangles, and thus the bipyramid is a deltahedron): the triangular, tetragonal, and pentagonal bipyramids. The tetragonal bipyramid with identical edges, or regular octahedron, counts among the Platonic solids, while the triangular and pentagonal bipyramids with identical edges count among the Johnson solids (J12 and J13).

 Triangular bipyramid Square bipyramid (Octahedron) Pentagonal bipyramid

## Kalidescopic symmetry

If the base is regular and the line through the apexes intersects the base at its center, the symmetry group of the n-gonal bipyramid has dihedral symmetry Dnh of order 4n, except in the case of a regular octahedron, which has the larger octahedral symmetry group Oh of order 48, which has three versions of D4h as subgroups. The rotation group is Dn of order 2n, except in the case of a regular octahedron, which has the larger symmetry group O of order 24, which has three versions of D4 as subgroups.

The digonal faces of a spherical 2n-bipyramid represents the fundamental domains of dihedral symmetry in three dimensions: Dnh, [n,2], (*n22), order 4n. The reflection domains can be shown as alternately colored triangles as mirror images.

D1h D2h D3h D4h D5h D6h ...

## Scalenohedron

A scalenohedron is topologically identical to a 2n-bipyramid, but contains congruent scalene triangles.

There are two types. In one type the 2n vertices around the center alternate in rings above and below the center. In the other type, the 2n vertices are on the same plane, but alternate in two radii.

The first has 2-fold rotation axes mid-edge around the sides, reflection planes through the vertices, and n-fold rotation symmetry on its axis, representing symmetry Dnd, [2+,2n], (2*n), order 2n. In crystallography, 8-sided and 12-sided scalenohedra exist.[1] All of these forms are isohedra.

The second has symmetry Dn, [2,n], (*nn2), order 2n.

The smallest scalenohedron has 8 faces and is topologically identical to the regular octahedron. The second type is a rhombic bipyramid. The first type has 6 vertices can be represented as (0,0,±1), (±1,0,z), (0,±1,−z), where z is a parameter between 0 and 1, creating a regular octahedron at z = 0, and becoming a disphenoid with merged coplanar faces at z = 1. For z > 1, it becomes concave.

4-scalenohedron geometric variations
z = 0.1 z = 0.25 z = 0.5 z = 0.95 z = 1.5

## Star bipyramids

Self-intersecting bipyramids exist with a star polygon central figure, defined by triangular faces connecting each polygon edge to these two points. A {p/q} bipyramid has Coxeter diagram .

5/2 7/2 7/3 8/3 9/2 9/4 10/3 11/2 11/3 11/4 11/5 12/5

isohedral even-sided stars can also be made with zig-zag offplane vertices, in-out isotoxal forms, or both, like this {8/3} form:

Regular Zig-zag regular Isotoxal Zig-zag isotoxal

## 4-polytopes with bipyramid cells

The dual of the rectification of each convex regular 4-polytopes is a cell-transitive 4-polytope with bipyramidal cells. In the following, the apex vertex of the bipyramid is A and an equator vertex is E. The distance between adjacent vertices on the equator EE = 1, the apex to equator edge is AE and the distance between the apices is AA. The bipyramid 4-polytope will have VA vertices where the apices of NA bipyramids meet. It will have VE vertices where the type E vertices of NE bipyramids meet. NAE bipyramids meet along each type AE edge. NEE bipyramids meet along each type EE edge. CAE is the cosine of the dihedral angle along an AE edge. CEE is the cosine of the dihedral angle along an EE edge. As cells must fit around an edge, NAA cos−1(CAA) ≤ 2π, NAE cos−1(CAE) ≤ 2π.

4-polytope properties Bipyramid properties
Dual of Coxeter
diagram
Cells VA VE NA NE NAE NEE Cell Coxeter
diagram
AA AE** CAE CEE
Rectified 5-cell 10 5 5 4 6 3 3 Triangular bipyramid 2/3 0.667 1/7 1/7
Rectified tesseract 32 16 8 4 12 3 4 Triangular bipyramid 2/3 0.624 2/5 1/5
Rectified 24-cell 96 24 24 8 12 4 3 Triangular bipyramid 22/3 0.745 1/11 5/11
Rectified 120-cell 1200 600 120 4 30 3 5 Triangular bipyramid 5 − 1/3 0.613 10 + 95/61 125 − 7/61
Rectified 16-cell 24* 8 16 6 6 3 3 Square bipyramid 2 1 1/3 1/3
Rectified cubic honeycomb 6 12 3 4 Square bipyramid 1 0.866 1/2 0
Rectified 600-cell 720 120 600 12 6 3 3 Pentagonal bipyramid 5 + 35/5 1.447 11 + 45/41 11 + 45/41
* The rectified 16-cell is the regular 24-cell and vertices are all equivalent – octahedra are regular bipyramids.
** Given numerically due to more complex form.

## Higher dimensions

In general, a bipyramid can be seen as an n-polytope constructed with a (n − 1)-polytope in a hyperplane with two points in opposite directions, equal distance perpendicular from the hyperplane. If the (n − 1)-polytope is a regular polytope, it will have identical pyramids facets. An example is the 16-cell, which is an octahedral bipyramid, and more generally an n-orthoplex is an (n − 1)-orthoplex bypyramid.


text:
# Attempt to prove that (a,b) = (a,b,a+b)

I want to check the validity of my proof to the following question.

Prove that (a,b) = (a,b,a+b) and more generally (a,b) = (a,b,ax+by).

Note that (a,b) is the greatest common divisor of $a$ and $b$, $a$ and $b$ are integers.

My Prove:

let $(a,b)$ = $g$ and $(a,b,a+b)$ = $g^*$. Since $g$|$a$, $g|b$ $\rightarrow$ $g|a+b$ implying that $g|g^*$. On the other hand, $g^*|a$, $g^*|b$, following that $g^*|g$.

From the previous argument, $g=\pm g^*$. However, $g,g^*$, by definition, cannot be negative, thereby, $g=g^*$ as required. The general case can be proved analogously.

• Compare with the proof here, which also gives your claim. – Dietrich Burde Sep 17 '18 at 12:06
• Thanks for commenting @DietrichBurde, nevertheless, it did not give a proof to the question I am asking neither check the proof I wrote. – Maged Saeed Sep 17 '18 at 12:15
• Yes, but you can easily check your proof with the given standard proofs. Do you have a special doubt about your proof? Then this would improve your question. Actually, $g\mid g*$ and $g*\mid g$ imply that $g$ and $g*$ are associated, and not necessarily $g=\pm g*$. Think of the ring $\Bbb{Z}[i]$. – Dietrich Burde Sep 17 '18 at 12:26
• to the point I am supposed to know "I did not do group and ring theory yet", it seems that my proof is correct. Thanks for your useful notes @DietrichBurde – Maged Saeed Sep 17 '18 at 12:52
• @Maged Saeed The (slight) problem is that you assume everybody knows what notation you use and about what kind of numbers you talk. $(a,b)$ can mean a many different things in math, depending on which branch you are in. And you don't state what kind of numbers $a,b\ldots$ are. I think you talk about integers, but you never mention it anywhere. It can be guessed only from mentions of 'negative', which don't make sense in many contexts where your question would otherwise make total sense. – Ingix Sep 17 '18 at 13:29

Depending on the level of your audience*, you may want to be more explicit in the implication "$$g|a$$ and $$g|b$$ implies $$g|a+b$$". In any case, showing the details here would certainly make the "analogously" for the general case more believable; as it is currently written, it took me a minute to see exactly how the analogy worked.


text:
# HDF5 and BioSQL solutions

I'm looking at better database/storage solutions for NCBI virus data, with all attributes particularly year and country of isolation, together with structural data, possible antibody data, T-cell data and bioinformatics data such as %GC etc... The amount of data is comparatively small, with a maximum size of 3 x ([6000 < no. viruses < 20000] for 10 genes) and each entry will contain nucleotide, amino acid and one or more pieces of alignment data (i.e. with indels).

The data will be used for numerous different calculations from structural biology, phylogenetics, and deep learning. Some of the calculations will require parallel processing. A typical calculation would be to identify a clade/similarity/difference then screen the database to look at the isolates information.

Previously I've used lots of flat files which are loaded at initiation and are held within a data pipeline either as an object (Python) or especially a multi-dimensional hash (Perl, preferred).

The two solutions that I think look suitable are:

1. BioSQL - The official Genbank solution, however my SQL commands are very basic and the documentation appears minimal (for BioSQL)
2. HDF5 (hierarchical data format) - this looks good because it uses complex hashes (dictionaries), and allows layering of multiple information onto a single Genbank sequence code (key). It has strong documentation. However, I understand this isn't a "database" (long term storage), but thats how I intend to use it.

JSON/Pickling I had a look at JSON, which to me looks okay, because I'm fond of complex hashes / dictionaries, but it appears to be more of a Web solution. Finally, "pickling" (Python) is cool, very cool, but I understand this not a database solution, because it risk compatibility issues, e.g. with future Python releases.

I am interested in knowing what archival systems board members are using, and a critique whether my assessment is ok for moving forward.

• If you are querying repeatedly and have multiple features on which you are applying search criteria, use a proper database with indexed features/columns/fields. – Alex Reynolds May 30 at 23:04

Just to conclude, @user172818 and @AlexReynolds are collectively saying either learn SQL or stick with CSV. Shoe-horning isn't an option.

A family member did industrial SQL databasing (Windows-based) and IMO its a parallel universe. Perl/hashes and Python Pandas/hierarchical-indexing and NCBI's "e-fetch/e-search" framework, are all my databasing data-munging I need so I'll stick with "flat-files".

If someone wants to post something to this extent, I'll sign the question complete.

HDF5, I suspect, has some sort of application to "higher order programming" (HoP),

... edit ... actually it doesn't I checked it out. Its application power is focused on calculations outside my remit and imposes restrictions on numpy array 'magic', so in my application pickling is a better short solution and longterm CSV.

• Hashes are memory intensive. Perhaps keep an eye on your memory usage, if you go this route. This is why indexing and sorting approaches are used. – Alex Reynolds Jun 4 at 2:37
• Thanks, I appreciate critical feedback. In defence of Perl v5.20 now has postfix dereferencing ->@* syntax, which a step forward for hashes. The data loads involved are less than a single higher eukaryotic genome. Obviously not doing dataframe style calculations in a hash ... its doable done (higher order programming), but possibly surpassed. – Michael G. Jun 4 at 13:10


text:
# Lesson 2

Solutions of Inequalities

### Problem 1

1. Select all numbers that are solutions to the inequality $$k > 5$$.

4

5

6

5.2

5.01

0.5

2. Draw a number line to represent this inequality.

### Problem 2

A sign on the road says: “Speed limit, 60 miles per hour.”

1. Let $$s$$ be the speed of a car. Write an inequality that matches the information on the sign.
2. Draw a number line to represent the solutions to the inequality.
3. Could 60 be a value of $$s$$? Explain your reasoning.

### Problem 3

One day in Boston, MA, the high temperature was 60 degrees Fahrenheit, and the low temperature was 52 degrees.

1. Write one or more inequalities to describe the temperatures $$T$$ that are between the high and low temperature on that day.
2. Show the possible temperatures on a number line.

### Problem 4

Describe a rigid transformation that you could use to show the polygons are congruent.

### Solution

(From Unit 1, Lesson 11.)

### Problem 5

1. Jada is taller than Diego. Diego is 54 inches tall (4 feet, 6 inches). Write an inequality that compares Jada’s height in inches, $$j$$, to Diego’s height.

2. Jada is shorter than Elena. Elena is 5 feet tall. Write an inequality that compares Jada’s height in inches, $$j$$, to Elena’s height.