Mathematica doesn’t recognize that $displaystyle Wleft( e^{e+1}right) =e$ and it’d be really nice if it did.

Is there any way to ‘teach’ it to treat ProductLog (E^(E+1)) as e so that it will simplify outputs as such?

Skip to content
# Tag: expression

## Is there a way to teach Mathematica to treat an expression as a protected constant?

## Proving that a language defined by a regular expression is equivalent to a right linear grammar

## fourier transform – how to describe delta convolution using integral expression

## Question about sum containing expression of prime:

## How to create Webform Pattern regular expression for restrict email domain

## linq – Make a method that uses Expression> for filtering and sorting more flexible

## automata – Write a regular expression – Contains an equal number of 01 and 10 subtrings

## How to simplify a very large expression?

How to simplify a very large expression? – Mathematica Stack Exchange
## intervals – Computing possibles values (range) for an (polynomial) expression that takes values from two 2-simplex

## trigonometry – Use trigonometric output expression for calculation in a next step

Mathematica doesn’t recognize that $displaystyle Wleft( e^{e+1}right) =e$ and it’d be really nice if it did.

Is there any way to ‘teach’ it to treat ProductLog (E^(E+1)) as e so that it will simplify outputs as such?

After thinking for a bit, I am not able to prove a double inclusion proof for the following problem. It seems very interesting to me.

Consider the regular expression $r= ((1(00)^∗1 + 0)1)^∗$ and the right-linear grammar $G= ({S,A},{0,1},S,P)$, where $P$ consists of the following rules:

$Srightarrow 1A|01S|lambda$

$Arightarrow 00A|11S$

Prove that $L(G)subseteq L(r)$ and vice versa.

We express the radiation from a source by the expression bellow:

$U(x,y)=frac{e^{jkz}e^{frac{k}{2z}(x^2+y^2)}}{jlambda z}iint_{-infty}^{+infty}u(x’,y’)e^{-jfrac{2pi}{lambda z}(x’x+y’y)}dx’dy’ $

the fourier transform is $f_x=frac{x}{lambda z}$ and $f_y=frac{y}{lambda z}$.

Our system bellow has two apartures which has distance between them.

each aparture has fourier transform of sinc $F(rect(ax)rect(by))=frac{1}{|ab|}sinc(frac{f_x}{a})sinc(frac{f_y}{b})$.

$F(delta(f_x-frac{a}{2},f_y-frac{b}{2}))=e^{(ipi(ax+by))}$.

I know that convolution with delta is a shift in space.

how to find using the integral expression shown above the fourier transform of the shape bellow?

Thanks.

I cannot use mathematica properly so forgive me for the following post:

I want to calculate values of following sum for large $x$:

$$sum_{pleq x} frac{1}{sqrt{ep}-1}$$

Where e is Euler’s constant.

Also I like to get plot and asymptotic of this sum.

I want to create a Pattern regular expression in a webform email element to reject form submission if user input in email element/field @gmail.com or @yahoo.com or @hotmail.com etc

Pattern like here

```
^(?=.*?b@gmail.comb).*$
```

I have a method in a service that performs a Linq-to-SQL query:

```
public async Task<IEnumerable<Incident>> GetIncidentsAsync<TOrderBy>(
Expression<Func<Incident, bool>> whereExpression,
Expression<Func<Incident, TOrderBy>> orderByExpression
)
{
return await (
from i in _context.Incidents
// inner join
.Include(i => i.IncidentType)
.Where(whereExpression)
.OrderBy(orderByExpression)
// left-outer join
join ft in _context.Driver on i.FaultTypeId equals ft.Id into ift
from faultTypes in ift.DefaultIfEmpty()
// left-outer join
join v in _context.Vehicles on i.VehicleSerialNo equals v.VehicleSerialNo into iv
from vehicles in iv.DefaultIfEmpty()
select new Incident
{
Id = i.Id,
IncidentTypeId = i.IncidentTypeId,
IncidentType = i.IncidentType,
// datetimes
Occurred = i.Occurred,
Reported = i.Reported,
Resolved = i.Resolved,
//
VehicleSerialNo = i.VehicleSerialNo,
Vehicle = vehicles,
//
DriverSerialNo = i.DriverSerialNo,
Driver = drivers
}
).ToListAsync();
}
```

Improvements:

- having to manually compose the
`Incident`

to be returned feels like an anti-pattern - handle situations where the
`whereExpression`

is null; this will try an exception now - handle situations where the
`orderByExpression`

is null; this will try an exception now - change the sorting direction from ascending to descending by changing the
`orderByExpression`

(if this is possible) - is there value to marking the method as
`<TOrderBy>`

?

Part of your confusion stems from the fact that there are two different formulations of Arden’s Lemma, which I’ll call LR and RL. To illustrate them, let’s take a simple FA with three states, $P,Q,R$, where $P$ is the start state and $R$ is the only final state. The transitions are

$$begin{array}{c|cc}

& 0 & 1\ hline

P & Q & varnothing\

Q & R & Q\

R & R & R

end{array}$$

It’s clear with a moment’s thought that the language accepted by this FA is denoted by the regular expression $01^*0(0+1)^*$, so let’s see what the two versions of Arden’s Lemma produce.

**LR**: In this version we generate the regular expression from left to right. If we have a state $X$ with a transition on $a$ to state $Y$ we will include the equation $X=aY$, along with any other terms that arise from transitions from $X$ to other states. Along with this, we add a “$+epsilon$” to the expression for $X$ if $X$ happens to be a final state. Having made the collection of equations, we may apply the simplification rule that says that whenever we have $X=rX + s$ for regular expressions $r, s$ we can replace the equation by its solution $X=r^*s$. Note that here the goal is to product a regular expression for the start state.

In the example above, we’ll have the equations

$$begin{align}

P&=0Q\

Q&=0R+1Q\

R&=(0+1)R+epsilon & text{since R is final}

end{align}$$

Substituting, we see that $R=(0+1)^*epsilon = (0+1)*$ and $Q=1^*(0R)=1^*0(0+1)^*$, and finally $P=0Q=01^*0(0+1)^*$, as we expected.

**RL**: In this version we construct the regular expression from right to left. The difference is that if we have a state $X$ with transition on $a$ to state $Y$ we include the equation $Y=Xa$, along with any similar terms. In this case, we add the “$+epsilon$” only to the *start* state’s equation and the substitution in this case says that if we have $X=Xr+s$ we have the solution $X=sr^*$.

Returning to our example, we’ll have

$$begin{align}

P&=epsilon & text{since $P$ is the start state and has no incoming transitions}\

Q&=P0+Q1\

R&=Q0+R(0+1)

end{align}$$

Now our goal is just opposite of what we had in the LR version: we want an expression for the *final* state, $R$. Working from the top down we have $Q=Q1+P0=Q1+0$ so $Q=01^*$ and $R=Q0(0+1)^*=01^*0(0+1)^*$: the same result generated in a different order.

Assuming you want to use the LR version, your equations should be

$$begin{align}

a_1&=0a_2\

a_2&=0a_3+1a_5+epsilon\

a_3&=0a_3+1a_4+epsilon\

a_4&=0a_3+1a_4\

a_5&=0a_6+1a_5\

a_6&=0a_6+1a_5+epsilon

end{align}$$

As for your problem with $a_5, a_6$, for example, we could do this:

$$begin{align}

a_5 &= 1^*(0a_6)=1^*0a_6 & text{Arden}\

a_6 &= 0^*(1a_5+epsilon) &text{Arden again, now substitute $a_6$}\

a_5 &= 1^*0(0^*(1a_5+epsilon))\

&= (1^*00^*1)a_5+1^*00^* &text{so we have}\

a_5 &= (1^*00^*1)^*1^*00^*

end{align}$$

Let $(p,q) in Delta_2$ and $(k,m) in Delta_2$, where

$Delta_2$ is the 2-simplex, that is,

$0leq pleq 1$, $0leq qleq 1$, and $0leq 1-p-qleq 1$.

Consider the expression

```
2 (p - q) + 3 k^2 (-1 + 2 p + q) +
k (1 + 6 (-1 + m) p + (3 - 6 m) q) -
m (1 + 3 p - 6 q + 3 m (-1 + p + 2 q))
```

I want to find the values that the expression above can take, given the

conditions on `p`

, `q`

, `m`

, and `k`

.

I tried an approach using `Interval`

```
expression(p_, q_, m_, k_) :=
2 (p - q) + 3 k^2 (-1 + 2 p + q) +
k (1 + 6 (-1 + m) p + (3 - 6 m) q) -
m (1 + 3 p - 6 q + 3 m (-1 + p + 2 q))
```

and observing the values that it takes

```
substitute($p_, $k_) :=
N((2 (p - q) + 3 k^2 (-1 + 2 p + q) +
k (1 + 6 (-1 + m) p + (3 - 6 m) q) -
m (1 + 3 p - 6 q + 3 m (-1 + p + 2 q)) /. {p -> $p,
k -> $k}) /. {q -> Interval({0, 1 - $p}),
m -> Interval({0, 1 - $k})})
```

then

```
Manipulate(substitute(p, q), {p, 0, 1, 1/10}, {q, 0, 1, 1/10})
```

However, using this values in the original expression, return lower values:

```
Table(expression(0, i, j, 0), {i, 0, 1, .1}, {j, 0, 1, .1}) //
Flatten // MinMax
```

Can’t use output sin[p] since Sin[p] is expected.

As a result of D[x, u] D[x, u] + D[y, u] D[y, u] + D[z, u] D[z, u] I’ve got a Mathematica output like u²+v²cos[p]² + v²sin[p]². As you see, cos and sin are given in lowercase letters, and Mathematica can’t use the expression for further simplifications since Cos and Sin are expected. What can I do to get the expected solution u²+v²?

DreamProxies - Cheapest USA Elite Private Proxies
100 Private Proxies
200 Private Proxies
400 Private Proxies
1000 Private Proxies
2000 Private Proxies
ExtraProxies.com - Buy Cheap Private Proxies
Buy 50 Private Proxies
Buy 100 Private Proxies
Buy 200 Private Proxies
Buy 500 Private Proxies
Buy 1000 Private Proxies
Buy 2000 Private Proxies
ProxiesLive
Proxies-free.com
New Proxy Lists Every Day
Proxies123