## FullSimplify a expression with a even function“`Df[x] == Df[-x]“`?

I want to simplify a expression with a even function`Df(x) == Df(-x)` like:

`FullSimplify(-(1/2) Df(x - x4) J(x) - 1/2 Df(-x + x4) J(x), Assumptions -> {Df(x) == Df(-x)})`

This code can not give the desired result like `-Df(-x + x4) J(x)`.

And the strange thing here is that if I replace x4 with x2, it works well.

`FullSimplify(-(1/2) Df(x - x2) J(x) - 1/2 Df(-x + x2) J(x), Assumptions -> {Df(x) == Df(-x)})`
will give `-Df(-x + x2) J(x)`.

So any solutions here for x4 or arbitrary symbol?

## simplifying expressions – RecurrentTable is not honoring FullSimplify

``````\$Version

(* "12.2.0 for Mac OS X x86 (64-bit) (December 12, 2020)" *)

Clear("Global`*")

nextK(k3_) := FullSimplify(3 + k3 + 2 Sqrt(2 + 3 k3));
``````

Add memorization to the definition of `G`

``````G(y_) := G(y) = nextK(G(y - 1));
G(1) := 3
Table(G(i), {i, 3})

(* {3, 2 (3 + Sqrt(11)), 15 + 4 Sqrt(11)} *)
``````

The `RecurrenceTable` results have not been simplified. Presumably, `nextK` is first evaluated symbolically where the simplification does not change the form. Subsequent numeric values do not then have the simplification applied.

``````seq = RecurrenceTable({a(n + 1) == nextK(a(n)), a(1) == 3}, a, {n, 1, 5})

(* {3, 6 + 2 Sqrt(11), 9 + 2 Sqrt(11) + 2 Sqrt(2 + 3 (6 + 2 Sqrt(11))),
12 + 2 Sqrt(11) + 2 Sqrt(2 + 3 (6 + 2 Sqrt(11))) +
2 Sqrt(2 + 3 (9 + 2 Sqrt(11) + 2 Sqrt(2 + 3 (6 + 2 Sqrt(11))))),
15 + 2 Sqrt(11) + 2 Sqrt(2 + 3 (6 + 2 Sqrt(11))) +
2 Sqrt(2 + 3 (9 + 2 Sqrt(11) + 2 Sqrt(2 + 3 (6 + 2 Sqrt(11))))) +
2 (Sqrt)(2 +
3 (12 + 2 Sqrt(11) + 2 Sqrt(2 + 3 (6 + 2 Sqrt(11))) +
2 Sqrt(2 + 3 (9 + 2 Sqrt(11) + 2 Sqrt(2 + 3 (6 + 2 Sqrt(11)))))))} *)

seq = seq // FullSimplify

(* {3, 2 (3 + Sqrt(11)), 15 + 4 Sqrt(11), 6 (5 + Sqrt(11)), 51 + 8 Sqrt(11)} *)
``````

Note that `FindSequenceFunction` can be used to generalize from the sequence provided by `RecurrenceTable`

``````f(n_) = FindSequenceFunction(seq, n) // FullSimplify

(* 6 - 2 Sqrt(11) + n (-6 + 2 Sqrt(11) + 3 n) *)
``````

Verifying that this result is equivalent to `G`

``````And @@ Table(G(n) == f(n), {n, 50})

(* True *)
``````

However, the results of `f` must also be subsequently simplified to obtain the same form as `G`

``````f /@ Range(3)

(* {3, 6 + 2 Sqrt(11), 6 - 2 Sqrt(11) + 3 (3 + 2 Sqrt(11))} *)

% // FullSimplify

(* {3, 2 (3 + Sqrt(11)), 15 + 4 Sqrt(11)} *)
``````

## simplifying expressions – FullSimplify not working

`````` [Phi]=[Pi]/8
G=Cos[[Phi]]*M+ I*Sin[[Phi]]*N
``````

In the answer to the above code I am getting an answer without any reduction as follows

I have tried FullSimplify, PowerExpand etc. Nothing works. Is there a way that I get the answer in fractional form after finding the value of Cos[[Pi]/8]

## simplifying expressions – Uncertain behaviour when using FullSimplify

While doing some (symbolic) calculations with Mathematica, I encountered a small problem with the FullSimpilify function that hopefully someone here might explain to me. More specifically, I fear that Mathematica oversimplified my equations (due to the arguments that I gave) and I wonder if there is a different way to parse my commands to get an output more to my liking.

Essentially, my Problem lies with the following two expressions:

1. `FullSimplify( Sin(n a (Pi))/n , Assumptions -> {n, a} (Element) Integers)`
and
2. `Limit( Sin(n a (Pi))/n , n -> 0)`

In another longer expression, I have several terms similar to (1) which are all simplified to “= 0” yet for n=0, I would at least like to get a warning that something strange is happening (because of n in the denominator). In the (continuous) Limit the expression does not equal 0. To avoid any confusion: the “n” parameter in my calculations is no Integer, but I want to check how the expression simplifies if n is at least close to an integer value. There are multiple terms like (1) with different factors (besides n, there is stuff like (n-2), (n+1), etc. ) in my longer expression so I would prefer to avoid going over them all by hand and check each case individually.

Is there a way to redo expression (1) but avoid mathematica so evaluate the `Sin(n a (Pi))` with the assumptions first? Such that a warning is returned for the case that the denominator also goes to 0 ?

I’m somewhat new to mathematica so there might be some more fundamental issues on how to use the software that I don’t know yet. Any recommendations are highly appreciated.

## simplifying expressions – Fullsimplify not working perfectly

Here I am using the below code for a simplification.

``````DB = (Sigma)*(Sigma)*(Phi)*(Phi)
BB = Sqrt(DB) // FullSimplify // PowerExpand
g = 1/DB

(Alpha)I = a(Phi)
(Alpha) = (Alpha)I - 0.5*BB*D(BB, (Phi))
(Alpha)s = (Alpha) - ((1/2)*BB*D(BB, (Phi)))
UG = 0.375 (Sigma)^2
Phi = UG - ((1/2)*(g*(Alpha)s*(Alpha)s)) // FullSimplify //
PowerExpand
``````

But I am getting a result without cancelling the common term $$phi$$
Below is what I am getting. But I need to cancel the common terms. Here $$a, sigma$$are constants. $$phi$$ is a variable

Result I got:

## FullSimplify of expressions with mathematical constants

L & # 39; writing:

``````{c1, c2, c3, c4, c5} = N({Tan(E), Sin(E), Tanh(E), E, Sinh(E)});

a = (c1 + c3) / 2;
b = Sqrt(c5^2 - (c2 - c4)^2) / 2;
c = 0;
d = (c2 + c4) / 2;
e = (c1 - c3) (c2 - c4) / (4 b);
f = c5 Sqrt(c5^2 - (c1 - c3)^2 - (c2 - c4)^2) / (4 b);
x = a + b Cos(t) + c Sin(t);
y = d + e Cos(t) + f Sin(t);

xmin = Minimize({x, 0 <= t <= 2π}, t)((1));
xmax = Maximize({x, 0 <= t <= 2π}, t)((1));
FullSimplify((xmin + xmax) / 2 == a)

ymin = Minimize({y, 0 <= t <= 2π}, t)((1));
ymax = Maximize({y, 0 <= t <= 2π}, t)((1));
FullSimplify((ymin + ymax) / 2 == d)
``````

we have:

True

True

this is what is desired. However, by making a simple change:

``````{c1, c2, c3, c4, c5} = {Tan(E), Sin(E), Tanh(E), E, Sinh(E)};
``````

we have:

True

...

that is to say, in the second case, there is no answer. So by defining the constants this other way:

``````SetAttributes(c1, Constant)
NumericQ(c1) = True;
N(c1, prec___) := N(Tan(E), prec)

SetAttributes(c2, Constant)
NumericQ(c2) = True;
N(c2, prec___) := N(Sin(E), prec)

SetAttributes(c3, Constant)
NumericQ(c3) = True;
N(c3, prec___) := N(Tanh(E), prec)

SetAttributes(c4, Constant)
NumericQ(c4) = True;
N(c4, prec___) := N(E, prec)

SetAttributes(c5, Constant)
NumericQ(c5) = True;
N(c5, prec___) := N(Sinh(E), prec)
``````

we have:

True

Minimize :: infeas: There are no values ​​of {t} for which the constraints 0 <= t <= 2π are satisfied and the objective function (...) has a real value.

Maximize :: infeas: There are no values ​​of {t} for which the constraints 0 <= t <= 2π are satisfied and the objective function (...) has a real value.

Infinity :: indet: Indeterminate expression -∞ + ∞ encountered.

Undetermined == (c2 + c4) / 2

where, apparently, another problem arises. How to solve everything?

## FullSimplify expression with mathematical constants

L & # 39; writing:

``````{c1, c2, c3, c4, c5} = N({Tan(E), Sin(E), Tanh(E), E, Sinh(E)});

a = (c1 + c3) / 2;
b = Sqrt(c5^2 - (c2 - c4)^2) / 2;
c = 0;
d = (c2 + c4) / 2;
e = (c1 - c3) (c2 - c4) / (4 b);
f = c5 Sqrt(c5^2 - (c1 - c3)^2 - (c2 - c4)^2) / (4 b);
x = a + b Cos(t) + c Sin(t);
y = d + e Cos(t) + f Sin(t);

xmin = Minimize({x, 0 <= t <= 2π}, t)((1));
xmax = Maximize({x, 0 <= t <= 2π}, t)((1));
FullSimplify((xmin + xmax) / 2 == a)

ymin = Minimize({y, 0 <= t <= 2π}, t)((1));
ymax = Maximize({y, 0 <= t <= 2π}, t)((1));
FullSimplify((ymin + ymax) / 2 == d)
``````

we have:

True

True

this is what is desired. However, by making a simple change:

``````{c1, c2, c3, c4, c5} = {Tan(E), Sin(E), Tanh(E), E, Sinh(E)};
``````

we have:

True

...

that is to say, in the second case, there is no answer. How to solve this problem?

## simplify expressions – Why is my answer not completely simplified with Simplify[] and FullSimplify[] the functions?

The code for my program is as follows:

``````Clear(f);
{\$RecursionLimit = Infinity};
f(n_) := If(n >= 1, f(n) = n - 1 + (-1)^n 2 f(n - 1), f(n) = 0);
FullSimplify(f(2020)/2)
``````

I am using Mathematica 12.0 and I am trying to find f (2020) / 2, but when I run the program, I get an un simplified result, the same using Simplify, FullSimplify and no function at all.

4815609167711586848007869227032356256312743227141422634144178841639258733223064376890242310095267513944017583269163671060520344846023756428821109590895218122099470699921398772560089491365798131644138341901312406104325088656339013004576875915896321903255827106838867819739516957333842785448961317408670542466925730316291502478820826826477731689044263368148553678106934675474617807970711635671594529280688929069927871781358399593472235076472408459246709587161732797507513416515412957925372883934815425197732231405475243618346154282741695439549613768814420303038299401914064527250128757745765469699137785079955/2

How to get a simplified result without the "/ 2"?

## matrix – FullSimplify does not simplify at all

I have some problems to simplify things with `FullSimplify`. Suppose a matrix `W = {{c[1, 1]c[1, 2]c[1, 3]}, {c[1, 2]c[2, 2]c[2, 3]}, {c[1, 3]c[2, 3]c[3, 3]}}` which must be unitary, so there are conditions on the c. I declare my conditions as
`cond = {{(Abs[c[c[c[c[1, 1]]^ 2 + Abs[c[c[c[c[1, 2]]^ 2 + Abs[c[c[c[c[1, 3]]^ 2) -> 1, (c[1, 2] Conjugate[c[c[c[c[1, 1]]+ c[2, 2] Conjugate[c[c[c[c[1, 2]]+ c[2, 3] Conjugate[c[c[c[c[1, 3]]) -> 0, (c[1, 3] Conjugate[c[c[c[c[1, 1]]+ c[2, 3] Conjugate[c[c[c[c[1, 2]]+ c[3, 3] Conjugate[c[c[c[c[1, 3]]) -> 0, (c[1, 1] Conjugate[c[c[c[c[1, 2]]+ c[1, 2] Conjugate[c[c[c[c[2, 2]]+ c[1, 3] Conjugate[c[c[c[c[2, 3]]) -> 0, (Abs[c[c[c[c[1, 2]]^ 2 + Abs[c[c[c[c[2, 2]]^ 2 + Abs[c[c[c[c[2, 3]]^ 2) -> 1, (c[1, 3] Conjugate[c[c[c[c[1, 2]]+ c[2, 3] Conjugate[c[c[c[c[2, 2]]+ c[3, 3] Conjugate[c[c[c[c[2, 3]]) -> 0, (c[1, 1] Conjugate[c[c[c[c[1, 3]]+ c[1, 2] Conjugate[c[c[c[c[2, 3]]+ c[1, 3] Conjugate[c[c[c[c[3, 3]]) -> 0, (c[1, 2] Conjugate[c[c[c[c[1, 3]]+ c[2, 2] Conjugate[c[c[c[c[2, 3]]+ c[2, 3] Conjugate[c[c[c[c[3, 3]]) -> 0, (Abs[c[c[c[c[1, 3]]^ 2 + Abs[c[c[c[c[2, 3]]^ 2 + Abs[c[c[c[c[3, 3]]^ 2-> 1)}}`
Then I want to diagonalize the next matrix `S = 1/3 {{-1, 2, 2}, {2, -1, 2}, {2, 2, -1}}` and I want the diagonal matrix to have the shape `diagS = DiagonalMatrix[{1,-1,-1}]` so I use
```FullSimplify[ConjugateTranspose[W].S.W - DiagonalMatrix[{1, -1, -1}], /.Flatten[cond]]```
`{{1/3 (-3 - Abs[c[c[c[c[1, 1]]^ 2 - Abs[c[c[c[c[1, 2]]^ 2 - Abs[c[c[c[c[1, 3]]^ 2 + 2 (c[1, 2] + c[1, 3]) Conjugate[c[c[c[c[1, 1]]+ 2 (c[1, 1] + c[1, 3]) Conjugate[c[c[c[c[1, 2]]+ 2 (c[1, 1] + c[1, 2]) Conjugate[c[c[c[c[1, 3]]), 1/3 ((-c[1, 2] + 2 (c[2, 2] + c[2, 3])) Conjugate[c[c[c[c[1, 1]]+ (2 c[1, 2] - c[2, 2] + 2 c[2, 3]) Conjugate[c[c[c[c[1, 2]]+ (2 (c[1, 2] + c[2, 2]) - c[2, 3]) Conjugate[c[c[c[c[1, 3]]), 1/3 ((-c[1, 3] + 2 (c[2, 3] + c[3, 3])) Conjugate[c[c[c[c[1, 1]]+ (2 c[1, 3] - c[2, 3] + 2 c[3, 3]) Conjugate[c[c[c[c[1, 2]]+ (2 (c[1, 3] + c[2, 3]) - c[3, 3]) Conjugate[c[c[c[c[1, 3]])}, {1/3 ((-c[1, 1] + 2 (c[1, 2] + c[1, 3])) Conjugate[c[c[c[c[1, 2]]+ (2 c[1, 1] - c[1, 2] + 2 c[1, 3]) Conjugate[c[c[c[c[2, 2]]+ (2 (c[1, 1] + c[1, 2]) - c[1, 3]) Conjugate[c[c[c[c[2, 3]]), 1/3 (3 - Abs[c[c[c[c[1, 2]]^ 2 - Abs[c[c[c[c[2, 2]]^ 2 - Abs[c[c[c[c[2, 3]]^ 2 + 2 (c[2, 2] + c[2, 3]) Conjugate[c[c[c[c[1, 2]]+ 2 (c[1, 2] + c[2, 3]) Conjugate[c[c[c[c[2, 2]]+ 2 (c[1, 2] + c[2, 2]) Conjugate[c[c[c[c[2, 3]]), 1/3 ((-c[1, 3] + 2 (c[2, 3] + c[3, 3])) Conjugate[c[c[c[c[1, 2]]+ (2 c[1, 3] - c[2, 3] + 2 c[3, 3]) Conjugate[c[c[c[c[2, 2]]+ (2 (c[1, 3] + c[2, 3]) - c[3, 3]) Conjugate[c[c[c[c[2, 3]])}, {1/3 ((-c[1, 1] + 2 (c[1, 2] + c[1, 3])) Conjugate[c[c[c[c[1, 3]]+ (2 c[1, 1] - c[1, 2] + 2 c[1, 3]) Conjugate[c[c[c[c[2, 3]]+ (2 (c[1, 1] + c[1, 2]) - c[1, 3]) Conjugate[c[c[c[c[3, 3]]), 1/3 ((-c[1, 2] + 2 (c[2, 2] + c[2, 3])) Conjugate[c[c[c[c[1, 3]]+ (2 c[1, 2] - c[2, 2] + 2 c[2, 3]) Conjugate[c[c[c[c[2, 3]]+ (2 (c[1, 2] + c[2, 2]) - c[2, 3]) Conjugate[c[c[c[c[3, 3]]), 1/3 (3 - Abs[c[c[c[c[1, 3]]^ 2 - Abs[c[c[c[c[2, 3]]^ 2 - Abs[c[c[c[c[3, 3]]^ 2 + 2 (c[2, 3] + c[3, 3]) Conjugate[c[c[c[c[1, 3]]+ 2 (c[1, 3] + c[3, 3]) Conjugate[c[c[c[c[2, 3]]+ 2 (c[1, 3] + c[2, 3]) Conjugate[c[c[c[c[3, 3]])}}`
Clearly, `FullSimplify` do not use my conditions since `-Abdos[c[c[c[c[1, 1]]^ 2 - Abs[c[c[c[c[1, 2]]^ 2 - Abs[c[c[c[c[1, 3]]^ 2 = -1`
Maybe I do not use it `FullSimplify` correctly, then I would be grateful for help. Thank you in advance.

## Functions – FullSimplify does not work well (requires a response based on a particular variable)

(new at Mathematica)

I'm trying to simplify the Schwarzian derivative of fw.r.t. u. (In[10]). Here f is first of the function of Weierstrass[8]) which has constraints (In[9])

``````In[8]: = f[u_] : = D[g[u], u]In[9]: = f[u]^ 2 == 4 g[u]^ 3 - a * g[u] - b

Outside[9]= Derived[1][g][u]^ 2 == -b - a g[u] + 4 g[u]^ 3

In[10]: = FullSimplify[F&#39;&#39;&#39;[F'''[F'''[f'''[u]/ F & # 39;[u] - 1.5 f & # 39;[u]^ 2 / f & # 39;[u]^ 2]
``````

gives the result (for whatever reason, Out[10] is of this form on the copy)

``````(
!  ( * SuperscriptBox[(g),
TagBox[
RowBox[{"(", "4", ")"}],
Derivative],
MultilineFunction-> None])[u] (g ^ [Prime][Prime])[u] - 1.5
!  ( * SuperscriptBox[(g),
TagBox[
RowBox[{"(", "3", ")"}],
Derivative],
MultilineFunction-> None])[u]^ 2) / (g ^ [Prime][Prime])[u]^ 2
``````

The output is in terms of prime numbers of g[u] and the expression is not simplified. Any help is appreciated. I would prefer that the answer is a function of g[u].