## turing machines – M does not accept [M] | ‘Correction’ of proof possible?

The language $$D={(M)|M((M))=0}$$ is not decidable because of the following argument:

Suppose there was a $$TM space M_D$$ that decides $$D$$. Then if we gave $$M_D space (M)$$, there would be two possible outcomes:

1. $$M_D((M_D))=1 text{ (accepts)}implies M_D text{ does accept }M_D$$, contradiction, because then $$M_D((M_D))=0$$ must be true.

2. $$M_D((M_D))=0 text{ (does not accept})implies M_D text{ does accept }M_D$$, contradiction, because then $$M_D((M_D))=1$$ must be true.

Anyways, I think most people are familiar with the proof.

My question is:

Where does the following argument fail? (I think this is important to understand other proofs where diagonalization is involved)

Suppose we have a $$TM$$ $$M_D$$ that decides if another $$TM space M$$ does not accept $$(M)$$. What if we just restrict $$M_D$$ so that it decides D for almost every other Turing Machine? So in this case we could say: $$M_D$$ does not decide for itself if $$M_D$$ accepts $$(M_D)$$, but it decides for every other Turing Machine.

Is this restriction useless because then it is possible to construct infinitely many Turing Machines for which $$M_D$$ can not decide whether they accept ‘themselves’?

## spellcheck – Is there a shortcut to undo MacOS’s spell check correction without completely disabling it?

spellcheck – Is there a shortcut to undo MacOS’s spell check correction without completely disabling it? – Ask Different

## What is a correct approach to gamma correction in OpenGL?

I’m currently reading about the topic of gamma correction and am a bit confused about what should I, as a game developer, do about it. There seem to be a few options here:

1. Don’t do anything at all and let OS, driver, monitor and user figure it out. Doesn’t seem to be the right one to me, but I may be wrong.
2. Explicitly request sRGB framebuffer and enable `GL_FRAMEBUFFER_SRGB` while doing rendering to display, leaving details to driver once again.
3. Explicitly request sRGB framebuffer and manually apply gamma correction in shader, potentially exposing slider to user.

In addition to above, there’s an idea to “uncorrect” textures, which assumes that they were made in sRGB color space to begin with, which seems pretty dubious to me: wouldn’t good textures already be properly using RGB colorspace instead of sRGB? Even if they weren’t, why not correct them on disk instead of doing extra calculations in runtime?

So, what approach should I take?

## spellcheck – Is there a way to get system-wide Grammarly correction on MacOS?

Is it possible to get Grammarly checking system-wide on MacOS? As far as I know, Grammarly only works as a browser plugin or Microsoft Office plugin (maybe more). Grammarly is fantastic, but the need to copy and paste my work into a designated Grammarly field is beyond inconvenient. Even a menu bar icon with a checker would be more convenient. I mainly work with 3rd-Party apps on Mac that don’t have a Grammarly plugin.

I like how on iPhone Grammarly is a keyboard extension that captures your spelling live as you type.

What are some alternatives if this is impossible?

## I can do change color of anything in Photoshop for \$5

#### I can do change color of anything in Photoshop

I will change the color of your photo or your product image or anything else. I will recolor or color the adjustment of your images.✪ See my services:✪

• Color Correction
• White balance
• Exposure
• Contrast
• Image resizing/cropping/Straighten
• Noise Reduction
• Sharping
• Skin smoothing
• Spot Removing
• and more

✪ ✪ Service Features ✪✪

✪ 100% Satisfaction Guaranteed.

✪ EXPRESS Delivery.

✪ Quick Responsiveness.

✪ Very LOW COST.

✪ High Quality.

Kind regards,

Kobir Miah

.

## pr.probability – Correction Continuity from Poisson to Normal Approximation

### Suppose cars arrive at a parking lot at a rate of 50 per hour. Let’s assume that the process is a Poisson random variable with λ = 50. Compute the probability that in the next hour the number of cars that arrive at this parking lot will be between 55 and 61. (Use Normal Approximation)

This is an easy problem but I am a bit confused about the continuity correction. I solved it twice in different ways and got different answers. So can anyone say which is correct? Here’s what I did.

$$mathbf1mathbf s mathbf t mathbf w mathbf a mathbf y:$$ $$P(55leqq Xleqq 61)=P({55-50over sqrt 50} leqq Zleqq {61-50over sqrt 50})=P(0.707leqq Zleqq 1.556)=P(leqq 1.556)-P(Zleqq 0.707)=0.1799$$ (using calculator)

$$mathbf2mathbf n mathbf d mathbf w mathbf a mathbf y:$$ $$P(55

Which one is correct?

## I will editing wedding photo and color correction in Lightroom for \$1

#### I will editing wedding photo and color correction in Lightroom

Welcome To My Gig Photo Editing Service in Lightroom.

Description-

I am editing Wedding, engagement, Birthday, Anniversary, Pre-Wedding, newborn, or any kind of event photos Color correction and adjustment (exposure, color, light, contrast, Noise reduction, Cropping etc) and very low price.

see my portfolio here: https://flic.kr/s/aHskHPKX4J

I am Editing Realistic, Natural, style. If you have any Preset can send me, i will use this for you.

My Services:

• Color Correction
• White balance
• Exposure
• Contrast
• Image resizing/cropping/Straighten
• Noise Reduction
• Sharping
• Skin smoothing
• Spot Removing
• and more

I will edit your full event photo/catalog contact me for information or a number of Photos contact me, I will create a custom offer for you.
Thank you

.(tagsToTranslate)photo(t)editing(t)wedding(t)image(t)lightroom(t)photoshop

## computer networks – Problem on probability given frame sizes and their error correction probabilities in a wireless system

I am stuck trying to solve the following question for a while

Bit error rate after demodulation in an wireless system = 1.0e-03.
The system has 4 possible frame sizes – 48 bytes, 96 bytes, 72 bytes
and 36 bytes with probabilities = 0.4, 0.25, 0.2 and 0.15
respectively. An error correction scheme is implemented on frames with
probabilities of correcting an erroneous frame = 0.6, 0.75, 0.7 and
0.5 respectively.
a) Find the average residual frame error rate.
b) Find the probability that, no frame has error after correction in a
series of 25 frames.
c) If a frame is in error after correction, find
the probability of its size being 48 bytes.

The main problem I am facing is understanding the role of the given bit error rate in this question.
I will lay down what I tried so far, I will start with
(c)

P(48F) = 0.4, P(96F) = 0.25, P(72F) = 0.2, P(36F) = 0.15
the probabilities of correcting an erroneous frame given the frame sizes are P(C|48F) = 0.6, P(C|96F) = 0.75, P(C|72F) = 0.7, P(C|36F) = 0.5

so the probabilities of not correcting an erroneous frame given frame size is 48 is
P(E|48F) = 1 – 0.6 = 0.4, same for others

probability of not correcting erroneous frame
P(E) = P(E|48F)*p(48F) + P(E|96F)*p(96F) + P(E|72F)*p(72F) + P(E|36F)*p(36F)

using naive bayes,
p(48F|E) = P(E|48F)*p(48F)/P(E) = 0.448

This is where I am getting lost

b)

Probability of no frames having error
P(C) = 1 – P(E)
so P(no error in 25 frames) = P(C)^{25}

a)

average frame size = 48 * 0.4 + 96 * 0.25 + 72 * 0.2 + 36 * 0.15 = 63 bytes
so the average frame error rate should be = 63 * 0.001/8

This is what I tried, my problem is understanding how to use the bit error rate for finding the given probabilities

## nikon – Times when I don’t want auto color correction or auto white point setting

There are times when I have taken pictures in a forest on a sunny day, and the light filtering through the leaves provides a nice green cast that I want to preserve. However, my Nikon Coolpix S9900 and Nikon D5500 always want to neutralize the cast. The solution doesn’t seem as clear cut as selecting a different white balance setting from the D5500’s Shooting Menu. And that seems like a somewhat cumbersome approach, even if there were to option to “preserve forest color cast”.

Does anyone have suggestions that work and are simple to preserve the color cast in such situations?

## coding theory – Error correction for windowed reads from cyclic tapes

I have an array of N symbols written on a cyclic tape. I read a sequence of M symbols starting from a random place on the tape. What error correcting scheme and even a coding scheme should I use for such “channel”?

Also will this problem be simpler if tape is not cyclic?