Making complex boolean circuits that give true as output only for a specific combination of boolean inputs

This is my first question on a stack exchange website so please bear with me. I am making challenges for a jeopardy style capture the flag event in my college and I had come across the minetest challenge in the hardware section of google CTF qualifier conducted last year. A clean and organized solution to this problem has been provided by liveoverflow.

I would like to design a simpler version of this problem for my college’s CTF event but I am unable to design a complex circuit that gives true output only for a specific combination of inputs. I know that a circuit with this functionality is not very difficult to implement and just needs to represent the following logic:

trueinput1 AND trueinput2 AND ... NOT falseinput1 AND NOT falseinput2 ...  

However I want it to be vast and complicated so that participants cannot decode its functionality just by doing a visual analysis. Is there any technique to complicate the boolean logic above and to design a corresponding circuit that looks ugly even for a small number of inputs(32/64).

Simplifying complex expresion (without ComplexExpand or User defined rules)

Many times, I’ve struggled with simplifying complex expressions, such as this extraordinarily simple expression, and Mathematica wont do it:

$  Assumptions = {l>0,a>0,a \[Element]Reals, l \[Element]Reals} Conjugate[(Exp[I a])^(2 l)] //FullSimplify 

Where Mathematica returns the same thing with no simplification. I told it the assumptions which make it very obvious to just change the sign of the exponent, and I don’t understand why it doesn’t work.

I looked here, but it seems like they have to define their own rules to do this kind of thing. I’m also saw here that you can do //ComplexExpand //FullSimplify for this expression, but it doesn’t seem to work in all cases. Why should it be nessecary and why doesn’t FullSimplify do it already? Also, I think ComplexExpand assumes that all variables are real, which was the case in this expression, but isn’t always the case. So how would I do it then?

What happens if a wizard attempts to create a complex object using True Polymorph?

Let’s say that a wizard tries to create a vessel using True Polymorph. Now, a vessel is made of a main wooden body and many other parts, more or less “removable” (e.g. sails, wheel, furniture, crates, ropes). Are they created along with the main body? Is it necessary to roll for some knowledge check to determine the result?

Addition of vectors defined over complex numbers

I want to do the following operation: Given $ k$ vectors $ \{|v_i\rangle \}$ each of dimension $ d$ ($ k < d$ ) where $ i$ denotes the vector’s index, I want to add them. Symbolically I want to perform the following operation:

$ $ |v\rangle = \sum_{i=1}^k c_i |v_i\rangle $ $

In the following case $ c_i$ ‘s and $ v_{ij}$ ‘s are all complex numbers. I have defined a vector “Call” such that,

Call = {c1,c2....ck} Vall = {v1,v2,v3...vk} 

Note that each vector $ v_i$ is defined to be

vi = {vi1, vi2,...vid} 

So basically I want the final expression to be something like this

v = {c1 v11 + c2 v21...+ ck vk1, c1 v12 + c2 v22...+ ck vk2,........ , ck v1d + c2 v2d...+ ck vkd} 

How do I implement the same?

Additional detail: In my case, $ k$ is 104, and $ d$ is 256.

I want to plot root of the following complex equation

I am trying to plot the roots of the following equation as mentioned in the code below But it is not giving me output. If anyone can resolve this problem for me is most welcome.

del = -1.5; del0 = 1.5; ome = 2; A1 = 0; B1 = 1; g0 = 2; G1 = 5; k1 = 0.1; kex = 0.1; X1 = g0/2*(1 - del0/ome)*A1; Y1 = P0/Sqrt[2]*g0/ome*B1; C1 = (G1/2)^2 + ome^2; kL = (k1 + kex)/2 - del0*(k1 - kex)/(2*ome); sol = Solve[{I*del*a1 +     I*g0*(1 - del0/ome)*A1*(X1*Dagger[a1]*a1 + Y1*Re[a1])/C1*ome +     I*P0/Sqrt[2]*(1 - del0/(2*ome)) +     I*P0*g0*B1/(Sqrt[2]*ome)*(X1*Dagger[a1]*a1 + Y1*Re[a1])/C1*     ome - kL*a1/2 - (k1 - kex)*g0*     B1/ome*(X1*Dagger[a1]*a1 + Y1*Re[a1])/C1*a1 == 0},  a1]; // FullSimplify  Plot[Evaluate@(a1 /. sol), {P0, 0, 2},   PlotStyle -> (Directive[Thick, ColorData[97][#]] & /@ {1, 3, 2}),    PlotLegends -> Placed[Automatic, {0.5, 0.625}]] 

Canceling factors from numerator and denominator with complex number

I have the following expression:

$ \text{expr} = i \frac{\sqrt{a-b}}{\sqrt{b-a}}x$ .

Clearly simplifying expression gives $ \text{expr}=x$ by cancelling the numerator and denominator. However, I am not able to perform this simplification in Mathematica. I have tried PowerExpand, Cancel, Factor, FullSimplify and Simplify. Nothing works. Can anyone suggest any method?

In what sense the computer program (Turing machine) can be considered as the complex system and its IIT Phi can be measured and improved?

I am reading https://global.oup.com/academic/product/a-world-beyond-physics-9780190871338?cc=us&lang=en& about one approach of complex systems’ theory for the emergence of the life. It is about the autocatalytic soup of molecules from which the life can emerge. Of course, one is thinking further – every computer program, every Turing machine is more ore less autocatalytic soup of interacting software components from which the consciousness, mind and Artificial General Intelligence (https://content.sciendo.com/view/journals/jagi/jagi-overview.xml) can emerge.

Of course – ther program (Turing machine) should be of sufficient complexity for such consciousness to emerge – and such complexity/level of consciousness can be measured by Phi measure of https://en.wikipedia.org/wiki/Integrated_information_theory .

My question is – how the theory of complex systems is applied to the software programs (including logic programs, sets of first order formulas, knowledge bases, functional programs, lambda terms), e.g. to derive the directions (modular organization, wealth of functionality, et.c) for evolving the programs into the programs with higher level of Phi, whith higer level of autonomy and consciousness? I presume, that consciousness is the driving force for the program to exhibit commonsense knowledge, for the capability to make generalizations and transfer skills among tasks (all those are very hot topics and deep learning community without almost any theory behind them). All these issues are the grails of current computer science and that is why my question is very applied in nature.

Currently computer programs and algorithms are developed in trial-and-error process. The development of software systems that are called cognitive architectures (http://bicasociety.org/cogarch/architectures.php) or that are called cognitive systems (http://www.cogsys.org/journal) is prominent features of such efforts. But maybe the theory of complex systems can be applied to such programs to determine why such programs exhibit or do not exhibit the capabilities of consciousness (as determined by IIT or any other computational theory of consciousness or mind – there are some others, academically sound) and what can be do on such programs to evolve them into capable systems with higher Phi. We have tried to design and program features but no cognitive architecture has achieved sufficient level of AGI. We can try still more harder. But maybe the theory of complex systems can provide some guidance to estimate the weak points and to provide some direction?

Just some reference for applying the theory of complex systems to the programs in the widest sense?

Download package to simplify Complex Conjugation

I want to use Needs to download QuickReIm package to simplify the Complex Conjugation, but I keep getting errors:

here is the Command:

Needs["QuickReIm`"] 

and here are the errors:

  Get::noopen: Cannot open QuickReIm`.   Needs::nocont: Context QuickReIm` was not created when Needs was    evaluated. 

Do you know the reason? Where can I find different packages and their uses?