In[]:=
MultiwaySystem[{"A""AA","A""B"},"A",5,"UnresolvedCriticalPairs"]
Out[]=
{{B,AA},{AAB,BB},{BAA,BB},{AABB,BBB},{BAAB,BBB},{BBB,BBAA}}
In[]:=
MultiwaySystem[{"A""AA","A""B"},"A",5]
Out[]=
{{A},{AA,B},{AAA,AB,BA},{AAAA,AAB,ABA,BAA,BB},{AAAAA,AAAB,AABA,ABAA,ABB,BAAA,BAB,BBA},{AAAAAA,AAAAB,AAABA,AABAA,AABB,ABAAA,ABAB,ABBA,BAAAA,BAAB,BABA,BBAA,BBB}}
In[]:=
MultiwaySystem[{"A""AA"},"A",5]
Out[]=
{{A},{AA},{AAA},{AAAA},{AAAAA},{AAAAAA}}
In[]:=
MultiwaySystem[{"A""AA"},"A",5,"UnresolvedCriticalPairs"]
Out[]=
{}
In[]:=
Table[MultiwaySystem[{"A""AB","B""A"},"A",t,"UnresolvedCriticalPairs"],{t,5}]
Out[]=
{{},{},{},{},{}}
Resolved critical pairs, Unresolved critical pairs
Resolved critical pairs, Unresolved critical pairs
"CriticalPairsList"{<|"Resolved"{XXXX},"Unresolved"{XXXXX}|>,XXXXX}
"UnresolvedCriticalPairsList"{XXX,XXX,XXX}
"UnresolvedCriticalPairs"(*atend*)
Free monoid
Free monoid
In[]:=
MultiwaySystem[{"""A","""B"},"",3]
Out[]=
{{},{A,B},{AA,AB,BA,BB},{AAA,AAB,ABA,ABB,BAA,BAB,BBA,BBB}}
Disconnected Components in States Graph are like nodes in Cayley graph
Disconnected Components in States Graph are like nodes in Cayley graph
Proofs of Causal Invariance
Proofs of Causal Invariance
{0,0}{1}
In[]:=
MultiwaySystem[{{0,0}{1}},{0,0,0},4,"StatesGraph"]
Out[]=
In[]:=
MultiwaySystem[{{0,0}{1}},{0,0},4,"StatesGraph"]
Out[]=
Start from 2 replacement rules, with disjoint variables
{{0,0}{1},{2,2}{3}}
Find a subterm that isn’t a single element
{0,0}
Can this unify this with {2,2}: i.e. does there exist a set of replacements for elements [or exprs if they can nest] such that these terms are transformed into each other [in some sense: are there terms isomorphic under relabeling?]
There is a unifier in this case:
BasicCriticalPair[{x_y_,u_v_}]:=
In[]:=
Subsequences[{1,2,1,3}]
Out[]=
{{},{1},{2},{1},{3},{1,2},{2,1},{1,3},{1,2,1},{2,1,3},{1,2,1,3}}
FindUnifier[e1_,e2_]:=XXXXFailure[]|{12,34}
{1,2,1,3},{2,4,2,6}
{y/.unifier,SequenceReplace[(x/.unifier),(x1/.unifier)(v/.unifier)]}
Cases[,{___,{
Turn the first rule into patterns
Turn the first rule into patterns
yθ is the result of the pattern match
Find out how the second rule fits into a subterm
Find out how the second rule fits into a subterm
{{0}{0,0},{0}{1}}
{{l___,x_,r___}{l,x,x,r}
In[]:=
SetAttributes[ϕ,Flat]
ϕ[x_]ϕ[x,x]
In[]:=
Cases[ϕ[0],ϕ[x_],{0}]
Out[]=
{ϕ[0]}
Cases[ϕ[0],ϕ[x_],{0}]
We need a way to get all the bindings for all the pattern variables.....
Goal: given the rule, enumerate possible bifurcations that can occur
Goal: given the rule, enumerate possible bifurcations that can occur
x{y,z}
{"A""AA","A""B"}
In[]:=
StringReplaceList[#,{"A""AA","A""B"}]&/@StringTuples["AB",3]
Out[]=
{{AAAA,BAA,AAAA,ABA,AAAA,AAB},{AAAB,BAB,AAAB,ABB},{AABA,BBA,ABAA,ABB},{AABB,BBB},{BAAA,BBA,BAAA,BAB},{BAAB,BBB},{BBAA,BBB},{}}
In[]:=
(#->StringReplaceList[#,{"A""AA","A""B"}])&/@StringTuples["AB",3]
Out[]=
{AAA{AAAA,BAA,AAAA,ABA,AAAA,AAB},AAB{AAAB,BAB,AAAB,ABB},ABA{AABA,BBA,ABAA,ABB},ABB{AABB,BBB},BAA{BAAA,BBA,BAAA,BAB},BAB{BAAB,BBB},BBA{BBAA,BBB},BBB{}}
In[]:=
(#->StringReplaceList[#,{"A""AA","A""B"}])&/@StringTuples["AB",4]
Out[]=
Is a new x->{y,z} deducible just by padding x?
In[]:=
DeBruijnSequence[2,4]
Out[]=
{0,0,0,0,1,0,0,1,1,0,1,0,1,1,1,1}
If the x->{y,z} was already found to be a critical pair, you can ignore that string
{"A""AA","A""B","AAA""BBA"}
StringTuples should be
In[]:=
StringTuples["AB",2Max[(StringLength@*First)/@{"A""AA","A""B","AAA""BBA"}]-1]
Out[]=
{AAAAA,AAAAB,AAABA,AAABB,AABAA,AABAB,AABBA,AABBB,ABAAA,ABAAB,ABABA,ABABB,ABBAA,ABBAB,ABBBA,ABBBB,BAAAA,BAAAB,BAABA,BAABB,BABAA,BABAB,BABBA,BABBB,BBAAA,BBAAB,BBABA,BBABB,BBBAA,BBBAB,BBBBA,BBBBB}
In[]:=
StringReplaceList["AABAA",{"A""AA","A""B","AAA""BBA"}]
Out[]=
{AAABAA,BABAA,AAABAA,ABBAA,AABAAA,AABBA,AABAAA,AABAB}
In[]:=
Union[Sort/@Tuples[StringReplaceList["AABAA",{"A""AA","A""B","AAA""BBA"}],2]]
Out[]=
{{AAABAA,AAABAA},{AAABAA,AABAAA},{AAABAA,AABAB},{AAABAA,AABBA},{AAABAA,ABBAA},{AAABAA,BABAA},{AABAAA,AABAAA},{AABAAA,AABAB},{AABAAA,AABBA},{AABAAA,ABBAA},{AABAAA,BABAA},{AABAB,AABAB},{AABAB,AABBA},{AABAB,ABBAA},{AABAB,BABAA},{AABBA,AABBA},{AABBA,ABBAA},{AABBA,BABAA},{ABBAA,ABBAA},{ABBAA,BABAA},{BABAA,BABAA}}
Given an LHS:
{"ABBB","BAA","AAAA"}
we need to find all overlapping cases of these things with themselves and each other
In[]:=
ResourceFunction["StringOverlaps"][{"ABBB","BAA"}]
Out[]=
{ABBBAA,BAABBB}
In[]:=
ResourceFunction["StringOverlaps"][{"ABBA","BB"}]
Out[]=
{ABBA}
In[]:=
ResourceFunction["StringOverlaps"][{"A","A"}]
Out[]=
{A}
In[]:=
ResourceFunction["StringOverlaps"][{"AAA","BBB"}]
Out[]=
{}