Computation Jockey:
Mind Over Matter

Daniel Rockwitz Reynolds
Teacher/Artist/Linguist

Join the Conversation #WolframTechConf

Computation Jockey

This is a concept where students will be able to “DJ” anythign in the computational universe using any external device with no time lag.

DJs never “drop beat” in set, so this should be benchmark for compuational play of future.

Wolfram Tech Converence Talks 
2016: Computation Jockey: Keeping The Vision (CJ) https://www.youtube.com/watch?v=sorPc1pXjF0
2017: Computation Jockey: For Education, Outreach, and Expression https://www.youtube.com/watch?v=erpIw56x2zk

Also Wolfram Summer School 2017 Project:
https://education.wolfram.com/summer/school/alumni/2017/reynolds/
http://community.wolfram.com/groups/-/m/t/1137186

NeuroSky: Mindwave

A single electrode EEG reader selling for around $100. Here we are demoing this concept on a simple toy device in order to show the potentials for future extension with multiple electrodes ETC (ala Brainduino). For integration with mulitple device setup and BCI wave of futue.

PArsing from ThinkConnector over Serial.

DJing the Universe

I have searched for last 11 years to find whether there is a computer code to the universe. This research brought me to Dr. Stephen Wolfram’s work and I propose this as my attempt at his question of whether there is a simple program that generates the universe.

Seven Axioms Described in Human Language. It is the hope to formalize these in the new proof and logical language options coming in Mathematica version 8 (taking them out of human language into formalizable). Then to test for “ghost particle statistics” in cosmology.

“Model 2” is a toy variation to show examples of how variation on model might work.



PLEASE EXCUSE THIS FIRST ATTEMPT IN NATURAL HUMAN LANGUAGE WHICH I AM TRYING TO FORMALIZE TO TEST
CONSTRUCTIVE (IE. MATHEMATICAL) CRITICISM WELCOMED TO PROVE/DISPROVE and MOVE FORWARD

Axiom Group 1: Starting Fundamentals and Definitions
Axiom 1: The Universe exists and will allow an evolution which is able to yield our current universe including our current place/position/region within it with all required complexity.
Axiom 2: The Universe starts from a finite beginning and this beginning is a point.
Axiom 3: The definition of a line segment has physical meaning and it is a unit made of two points and an additional segment between them.

Axiom Group 2: Existence of Time and Time with Model Location/Definitions
Axiom 4: There is a fundamental recursive operation applied on the universe itself.
Axiom 5: There is space, and it has a physical meaning whose acceptance yields necessarily ghost particle statistics which are non-trivial and whose properties are acted upon by the recursive procedure of time. 

Axiom Group 3: Causality in Time and Space
Axiom 6: The universe can only apply fundamental recursive operation one operation at a time in sequence.
* (ONLY IN MODEL 2) Axiom 7: The universe can “multiply” in spatial extention and this is only via the number of directions allowed by the degrees of freedom intrinsic to the dimension it is currently existing maximally at recursively in time.

Axiom Group 4: Cell-f Simularity
Axiom 8 (7 in Model 1): The universe is composed of discrete objects called cells which have equal number to the number of parts for n-cube of that d.

GUFT=  
FUNDAMENTAL REPLICATOR REPLICATION PATTERN=
PRIMAL CA RESURSIVE FUNCTION=
PRIMAL FRACTAL RECURSIVE FUNCTION=
SOURCE OF PRIMAL “FEEDBACK SYSTEM”??????

MODEL 1
S:Ubits(t)=
  {1}:(∑_(n=0)^t)(3^n)*(({{t}, {n}}))*((2^(t-n)))2
+{0}:(∑_(n=0)^t)((3^t)-(3^n)*(2^(t-n)))*(({{t}, {n}}))*(2^(t-n))
+{1}:(∑_(m=1)^t)(∑_(n=0)^(m-1))(3^n)*(({{m-1}, {n}}))*((2^((m-1)-n)))2*(({{t}, {m-1}}))*(2^(t-(m-1)))
+{0}:(∑_(m=1)^t)(∑_(n=0)^(m-1))((3^t)-(3^n)*(2^((m-1)-n)))*(({{m-1}, {n}}))*((2^((m-1)-n)))*(({{t}, {m-1}}))*(2^(t-(m-1)))
=
  {1}:
⊂(3^t)*(5^t)*2

StateUBits1InModel1[t_]:= Sum[(3^n)*Binomial[t,n]*(2^(t-n))^2,{n,0,t}]

StateUBits0InModel1[t_]:= Sum[((3^t)-(3^n)*2^(t-n))*Binomial[t,n]*(2^(t-n)),{n,0,t}]

StateUBits1OutModel1[t_]:=Sum[(3^n)*Binomial[(m-1),n]*((2^((m-1)-n))^2)*Binomial[t,(m-1)]*(2^(t-(m-1))),{m,1,t},{n,0,(m-1)}]

StateUBits0OutModel1[t_]:=Sum[((3^t)-(3^n)*2^((m-1)-n))*Binomial[(m-1),n]*((2^((m-1)-n)))*Binomial[t,(m-1)]*(2^(t-(m-1))),{m,1,t},{n,0,(m-1)}]

StateUBits1InModel1[7]+StateUBits0InModel1[7]+StateUBits1OutModel1[7]+StateUBits0OutModel1[7]

MODEL 2
S:Ubits(t)=
  {1}:(∑_(n=0)^t)(3^n)*(2t-1)n*(({{t}, {n}}))*((2^(t-n)))2
+{0}:(∑_(n=0)^t)((3^t)-(3^n)*(2^(t-n)))*(2t-1)n*(({{t}, {n}}))*(2^(t-n))
+{1}:(∑_(m=1)^t)(∑_(n=0)^(m-1))(3^n)*(2t-1)n*(({{m-1}, {n}}))*((2^((m-1)-n)))2*(({{t}, {m-1}}))*(2^(t-(m-1)))
+{0}:(∑_(m=1)^t)(∑_(n=0)^(m-1))((3^t)-(3^n)*(2^((m-1)-n)))*(2t-1)n*(({{m-1}, {n}}))*((2^((m-1)-n)))*(({{t}, {m-1}}))*(2^(t-(m-1)))
⊂(3^t)*((((2t+1)+2))^t)*2

StateUBits1InModel2[t_]:= Sum[(3^n)*((2t-1)^n)*Binomial[t,n]*(2^(t-n))^2,{n,0,t}]

StateUBits0InModel2[t_]:= Sum[((3^t)-(3^n)*2^(t-n))*((2t-1)^n)*Binomial[t,n]*(2^(t-n)),{n,0,t}]

StateUBits1OutModel2[t_]:=Sum[(3^n)*((2t-1)^n)*Binomial[(m-1),n]*((2^((m-1)-n))^2)*Binomial[t,(m-1)]*(2^(t-(m-1))),{m,1,t},{n,0,(m-1)}]

StateUBits0OutModel2[t_]:=Sum[((3^t)-(3^n)*2^((m-1)-n))*((2t-1)^n)*Binomial[(m-1),n]*((2^((m-1)-n)))*Binomial[t,(m-1)]*(2^(t-(m-1))),{m,1,t},{n,0,(m-1)}]

StateUBits1InModel2[7]+StateUBits0InModel2[7]+StateUBits1OutModel2[7]+StateUBits0OutModel2[7]

MODEL 1 is able to generate Pascal’s Triangle:
(This may be able to form a bridge to “standard number theory”) 

Since Binarized Pascal’s Triangle can generate Sierpinski’s Triangle (using last digits of binary for array plot) we can try to look at binary rule sets of Elementary Wolfram CAs and try to find a “physical?” correspondance understanding

((# of individual specific n faces per the larger n-cube (t))/(# of {1}s per each individual specific n faces per the larger n-cube (t)))*(3^n)
=

(((({{t}, {n}})) * (2^(t-n)))/((3^n)* (2^(t-n))))*(3^n)=(({{t}, {n}}))

n=Table[((Binomial[t,n]*2^(t-n))/((3^n)*(2^(t-n))))*3^n,{t,0,10},{n,0,10}]

Grid[n]

({{1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, {1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0}, {1, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0}, {1, 3, 3, 1, 0, 0, 0, 0, 0, 0, 0}, {1, 4, 6, 4, 1, 0, 0, 0, 0, 0, 0}, {1, 5, 10, 10, 5, 1, 0, 0, 0, 0, 0}, {1, 6, 15, 20, 15, 6, 1, 0, 0, 0, 0}, {1, 7, 21, 35, 35, 21, 7, 1, 0, 0, 0}, {1, 8, 28, 56, 70, 56, 28, 8, 1, 0, 0}, {1, 9, 36, 84, 126, 126, 84, 36, 9, 1, 0}, {1, 10, 45, 120, 210, 252, 210, 120, 45, 10, 1}})

GHOST CUBE STATISTICS THAT I POSIT AS NONTRIVIAL (AXIOM 5)

External Devices Mixing Analog and Digital

Control:
AKAI APC40 for Controlling MIDI
(Uses Hairless Serial MIDI to COM Converter)


External:
Edirol V-4 Video Mixer for “Feedback” Effects
Doepfer Eurorack Power Unit with Dave Jones MVIP for Colorization
Korg KPE-1 Entrancer for Video Effects

OUR ULTIMATE HOPE FOR FUTURE (OVER NEXT YEAR):
To mix together a fully controllable Digital/Analog workstation for 
Both Pure Mathematics and Complexity Science (CAs/Fractals, etc...)
With all the future Video/Image/Audio Processing of Mathematics V. 12.0+

FULL IMAX With Stereoscopy for Student Competitions and Shows LIVE
w/ ATMOS SOUND
*Possible Partnerships between Wolfram/NVIDIA/IMAX*

DeviceClose[port]

port=DeviceOpen["Serial","COM4"]

Parser for the whole MIDI input:

$debug=False;

echoFunc=If[TrueQ[$debug], Echo, #1&];

ClearAll[parseMidi];
parseMidi[list_List]:=parseMidi/@MidiCommand@@@Partition[list,3]

Parser for sliders 1-8:

parseMidi[MidiCommand[slider_,7,value_]]:=moveSlider@@echoFunc[{slider-175,value},"Slider"]

Parser Buttons Group1:

parseMidi[MidiCommand[type_,y_/;(53≤y≤57),127]]:=With[{pushDown=144≤type≤151},
pressButton@@echoFunc[{"Group1",(*x*)If[pushDown,type-143,type-127],(*y*)y-52,If[pushDown,"Down","Up"]},"Button group 1"]]

parseMidi[MidiCommand[type_,16,_]]:=
pressTrack@@echoFunc[{"Track Selection",type-175}]

(*CreateDocument[Dynamic[parseMidi[DeviceReadBuffer[port]];]];*)

ClearAll[moveSlider];
imagesize=200;
velocityScale=0;
velocityX=0;
velocityY=0;

moveSlider[1,value_]:=x=value

moveSlider[2,value_]:=y=value

moveSlider[4,value_]:=scale=Rescale[value,{0,127},{0.05,1}]
(*moveSlider[4,value_]:=velocityScale=Rescale[value,{0,127},{-1,1}]*)
moveSlider[5,value_]:=offsetX=Rescale[value,{0,127},{-1,1}]
moveSlider[6,value_]:=offsetY=Rescale[value,{0,127},{-1,1}]
(*moveSlider[5,value_]:=velocityX=Rescale[value,{0,127},{-1,1}]
moveSlider[6,value_]:=velocityY=Rescale[value,{0,127},{-1,1}]*)
moveSlider[8,value_]:=imagesize=10*value

pressTrack["Track Selection",value_]:=n=value

imagesize=200;
scale=1;
offsetX=0;
offsetY=0;
y=0;
x=0;
n=1;

pressButton["Group1",x_,y_,type_]:=b={x,y}

(*Dynamic[JuliaSetPlot[x+y*I,PerformanceGoal->If[AbsoluteTime[]-lastTouched<1,"Speed","Quality"]]]*)

(*Dynamic[JuliaSetPlot[x+y*I,PerformanceGoal->"Speed"]]*)

socket = SocketConnect["127.0.0.1:13854"];
WriteString[socket,"{\"enableRawOutput\": true, \"format\": \"Json\"}"];
eegNumber = 0;

Dynamic[(
parseMidi[DeviceReadBuffer[port]];
If[n=!=1,
ArrayPlot[CellularAutomaton[x,CenterArray[2(y+3)],y+2],Frame->None,ImageSize->{imagesize,imagesize}],
a=Rescale[x,{0,127},{-1,1}];
b=Rescale[y,{0,127},{-1,1}];
g=JuliaSetPlot[a+b*I,PerformanceGoal->"Speed",PlotRange->scale{{-1,1}+offsetX,{-1,1}+offsetY},FrameTicks->None,ImageSize->imagesize]])]

Dynamic[(
parseMidi[DeviceReadBuffer[port]];
If[n=!=1,
ArrayPlot[CellularAutomaton[x,CenterArray[2(y+3)],y+2],Frame->None,ImageSize->{imagesize,imagesize}],
a=Rescale[x,{0,127},{-1,1}];
b=Rescale[y,{0,127},{-1,1}];
(*Print[{a,b,imagesize}];*)
JuliaSetPlot[a+b*I,PerformanceGoal->"Speed",PlotRange->scale{{-1,1},{-1,1}},FrameTicks->None,ImageSize->imagesize]])]

g

xz

x

y

Dynamic[g]

While[True,
parseMidi[DeviceReadBuffer[port]];
s=Read[socket,Record,RecordSeparators->{{"{"},{"}"}}];
If[StringMatchQ[s, "\"rawEeg*"],
eegNumber=ToExpression[StringSplit[s,":"][[2]]]
];
If[n=!=1,
ca=CellularAutomaton[x,CenterArray[2(y+3)],y+2];
ca=ca/. 1->RGBColor[0,0,Mod[eegNumber,256]/256.];
g=ArrayPlot[ca,Frame->None,ImageSize->{imagesize,imagesize}],
(* else *)
a=Rescale[x,{0,127},{-1,1}];
b=Rescale[y,{0,127},{-1,1}];
g=JuliaSetPlot[a+b*I,PerformanceGoal->"Speed",PlotRange->scale{{-1,1}+offsetX,{-1,1}+offsetY},FrameTicks->None,ImageSize->imagesize]
];
Pause[0.05]
]

a

b

offsetX

Read[socket,Record,RecordSeparators->{{"{"},{"}"}}]

n

g//InputForm

CellularAutomaton[3,CenterArray[2(2+3)],2+2]

Mod[280,256]

Read[socket,Byte]

y