WolframAlpha.com
WolframCloud.com
All Sites & Public Resources...
Products & Services
Wolfram|One
Mathematica
Wolfram|Alpha Notebook Edition
Programming Lab
Finance Platform
SystemModeler
Wolfram Player
Wolfram Engine
WolframScript
Enterprise Private Cloud
Enterprise Mathematica
Wolfram|Alpha Appliance
Enterprise Solutions
Corporate Consulting
Technical Consulting
Wolfram|Alpha Business Solutions
Resource System
Data Repository
Neural Net Repository
Function Repository
Wolfram|Alpha
Wolfram|Alpha Pro
Problem Generator
API
Data Drop
Products for Education
Mobile Apps
Wolfram Player
Wolfram Cloud App
Wolfram|Alpha for Mobile
Wolfram|Alpha-Powered Apps
Services
Paid Project Support
Wolfram U
Summer Programs
All Products & Services »
Technologies
Wolfram Language
Revolutionary knowledge-based programming language.
Wolfram Cloud
Central infrastructure for Wolfram's cloud products & services.
Wolfram Science
Technology-enabling science of the computational universe.
Wolfram Notebooks
The preeminent environment for any technical workflows.
Wolfram Engine
Software engine implementing the Wolfram Language.
Wolfram Natural Language Understanding System
Knowledge-based broadly deployed natural language.
Wolfram Data Framework
Semantic framework for real-world data.
Wolfram Universal Deployment System
Instant deployment across cloud, desktop, mobile, and more.
Wolfram Knowledgebase
Curated computable knowledge powering Wolfram|Alpha.
All Technologies »
Solutions
Engineering, R&D
Aerospace & Defense
Chemical Engineering
Control Systems
Electrical Engineering
Image Processing
Industrial Engineering
Mechanical Engineering
Operations Research
More...
Finance, Statistics & Business Analysis
Actuarial Sciences
Bioinformatics
Data Science
Econometrics
Financial Risk Management
Statistics
More...
Education
All Solutions for Education
Trends
Machine Learning
Multiparadigm Data Science
Internet of Things
High-Performance Computing
Hackathons
Software & Web
Software Development
Authoring & Publishing
Interface Development
Web Development
Sciences
Astronomy
Biology
Chemistry
More...
All Solutions »
Learning & Support
Learning
Wolfram Language Documentation
Fast Introduction for Programmers
Wolfram U
Videos & Screencasts
Wolfram Language Introductory Book
Webinars & Training
Summer Programs
Books
Need Help?
Support FAQ
Wolfram Community
Contact Support
Premium Support
Paid Project Support
Technical Consulting
All Learning & Support »
Company
About
Company Background
Wolfram Blog
Events
Contact Us
Work with Us
Careers at Wolfram
Internships
Other Wolfram Language Jobs
Initiatives
Wolfram Foundation
MathWorld
Computer-Based Math
A New Kind of Science
Wolfram Technology for Hackathons
Student Ambassador Program
Wolfram for Startups
Demonstrations Project
Wolfram Innovator Awards
Wolfram + Raspberry Pi
Summer Programs
More...
All Company »
Search
WOLFRAM COMMUNITY
Connect with users of Wolfram technologies to learn, solve problems and share ideas
Join
Sign In
Dashboard
Groups
People
Message Boards
Answer
(
Unmark
)
Mark as an Answer
GROUPS:
Wolfram Science
Data Science
Physics
Wolfram Language
Machine Learning
Wolfram Summer School
Wolfram Function Repository
2
Minzhao (Henry) Liu
[WWS21] Application of Machine Learning in Complex System Simplification
Minzhao (Henry) Liu, University of Chicago
Posted
3 months ago
1020 Views
|
0 Replies
|
2 Total Likes
Follow this post
|
Application of Machine Learning in Complex System Simplification
Minzhao Liu
Abstract
For any kind of rule based updating systems with bidirectional rules, we can view all states in the multiway system as equivalent. Such perspective is useful for theorem proving, etc. In particular, there is a strong interest in finding general strategies to apply rules to simplify complex states, where the complexity can be the number of nodes or edges in a hypergraph, the number of letters in a string substitution system or the number of spiders and edges in a ZX diagram. Many simplification procedures require temporary added complexity to rearrange the state to a more desirable form, where simplifying rules can apply, limiting the power of simply descending along some heuristic. With infinite computational power, a multiway graph can be constructed and brute-force the optimal solution, which is impractical due to the exponential or even factorial growth in complexity with system sizes or generations of evolution.
We present a Monte-Carlo tree search (MCTS) based approach to reduce the computational need. An Upper-Confidence Bounds Applied to Trees (UCT) algorithm is used to balance the ‘exploration’ of new states and ‘exploitation’ of known states with high values are balanced. This is achieved by evaluating a ‘heuristic’ value of each state which contains information about the state itself and the extent of exploration. The heuristic function itself can also be based on a neural network.
Introduction
For simplicity of understanding and reducing the complexity of computation, we study string substitution systems as an example. The goal of the algorithm is to ‘simplify’ a randomly chosen string using the rules given in order to reach the shortest string possible. Since we are dealing with a problem of proving equivalence of different strings and finding the shortest form, the rules applied are bidirectional. Simplifying rules are the half of all the rules that lead to a reduction in the length of the string.
One approach is to do a comprehensive tree search by applying all applicable rules to different parts of the string and do the same for their children. The shortest child string would be the desired outcome. However, the computational complexity of such an approach is huge, as many substitutions increase the length of the strings and lead to even more children per iteration. A simple fix to this issue is to limit the choice of rules applied to simplifying rules, which shortens the strings and reduces the space of search. The complexity is dramatically reduced, but many simplifying states are now impossible to reach. It is imaginable that for certain simplification to take place, strings need to become longer and be arranged to a new form that allows further simplification. Limiting the rules to simplifying rules eliminates such simplification routes.
It is therefore obvious that some kind of tree search is necessary and intelligent search algorithms are needed to reduce the complexity. The crux of our algorithm is to explore only worth-while states and not others. Two criterion are used to determine which states are worth exploring: that the state is likely to lead to simplification and that it is under-explored. This is presented to the algorithm as a ‘heuristic’ score of a state, where one part characterizes the potential to simplification and another characterize the extent of exploration. This approach constitutes an Upper-Confidence Bounds Applied to Trees (UCT) algorithm for Monte-Carlo tree search (MCTS).
We compare the following approaches for string simplification: brute-force tree search, brute-force tree search limited to simplifying rules, choose the shortest string after each two layer tree and our MCTS algorithm. brute-force tree search is computational infeasible, and the other two does not lead to longer simplified results compared to our MCTS algorithm.
Definition of Rules
To demonstrate the algorithm, we need to choose a rule with sufficient complexity such that brute-force algorithm is infeasible.
Since we are dealing with a problem of proving equivalence of different strings and finding the shortest form, the rules applied are bidirectional.
Simplifyingrules are the half of all the rules that lead to a reduction in the length of the string.
The experience is that when rules 0, 1, and 2 are not symmetrized (they are not simple replacement of letters to each other, i.e. rules1 and rules0 are the same with “A” replaced with “C”, but rules2 is not of that nature), the rules lead to a need for non-trivial simplification procedures.
I
n
[
]
:
=
r
u
l
e
s
0
=
{
"
A
"
"
A
B
"
,
"
A
B
B
A
"
"
A
"
,
"
B
A
A
B
"
"
B
B
"
,
"
A
B
A
B
"
"
B
A
A
"
,
"
A
A
"
"
A
B
A
"
,
"
B
A
"
"
B
B
B
B
"
,
"
A
B
"
"
A
"
,
"
A
"
"
A
B
B
A
"
,
"
B
B
"
"
B
A
A
B
"
,
"
B
A
A
"
"
A
B
A
B
"
,
"
A
B
A
"
"
A
A
"
,
"
B
B
B
B
"
"
B
A
"
}
;
r
u
l
e
s
1
=
{
"
C
"
"
C
B
"
,
"
C
B
B
C
"
"
C
"
,
"
B
C
C
B
"
"
B
B
"
,
"
C
B
C
B
"
"
B
C
C
"
,
"
C
C
"
"
C
B
C
"
,
"
B
C
"
"
B
B
B
B
"
,
"
C
B
"
"
C
"
,
"
C
"
"
C
B
B
C
"
,
"
B
B
"
"
B
C
C
B
"
,
"
B
C
C
"
"
C
B
C
B
"
,
"
C
B
C
"
"
C
C
"
,
"
B
B
B
B
"
"
B
C
"
}
;
r
u
l
e
s
2
=
{
"
A
"
"
A
C
C
"
,
"
A
A
C
"
"
C
A
C
C
"
,
"
C
C
A
A
"
"
A
A
A
A
C
"
,
"
A
C
C
"
"
A
"
,
"
C
A
C
C
"
"
A
A
C
"
,
"
A
A
A
A
C
"
"
C
C
A
A
"
}
;
r
u
l
e
s
3
=
{
"
A
B
C
"
"
A
C
B
B
"
,
"
B
A
A
A
C
C
"
"
A
A
C
C
B
"
,
"
A
B
C
C
A
"
"
A
C
C
B
B
A
A
C
"
,
"
A
C
B
B
"
-
>
"
A
B
C
"
,
"
A
A
C
C
B
"
"
B
A
A
A
C
C
"
,
"
A
C
C
B
B
A
A
C
"
"
A
B
C
C
A
"
}
;
r
u
l
e
s
=
J
o
i
n
[
r
u
l
e
s
0
,
r
u
l
e
s
1
,
r
u
l
e
s
2
,
r
u
l
e
s
3
]
;
s
i
m
p
l
i
f
y
i
n
g
r
u
l
e
s
0
=
{
"
A
B
B
A
"
"
A
"
,
"
B
A
A
B
"
"
B
B
"
,
"
A
B
A
B
"
"
B
A
A
"
,
"
A
B
"
"
A
"
,
"
A
B
A
"
"
A
A
"
,
"
B
B
B
B
"
"
B
A
"
}
;
s
i
m
p
l
i
f
y
i
n
g
r
u
l
e
s
1
=
{
"
C
B
B
C
"
"
C
"
,
"
B
C
C
B
"
"
B
B
"
,
"
C
B
C
B
"
"
B
C
C
"
,
"
C
B
"
"
C
"
,
"
C
B
C
"
"
C
C
"
,
"
B
B
B
B
"
"
B
C
"
}
;
s
i
m
p
l
i
f
y
i
n
g
r
u
l
e
s
2
=
{
"
A
C
C
"
"
A
"
,
"
C
A
C
C
"
"
A
A
C
"
,
"
A
A
A
A
C
"
"
C
C
A
A
"
}
;
s
i
m
p
l
i
f
y
i
n
g
r
u
l
e
s
3
=
{
"
B
A
A
A
C
C
"
"
A
A
C
C
B
"
,
"
A
C
B
B
"
"
A
B
C
"
,
"
A
C
C
B
B
A
A
C
"
"
A
B
C
C
A
"
}
s
i
m
p
l
i
f
y
i
n
g
r
u
l
e
s
=
J
o
i
n
[
s
i
m
p
l
i
f
y
i
n
g
r
u
l
e
s
0
,
s
i
m
p
l
i
f
y
i
n
g
r
u
l
e
s
1
,
s
i
m
p
l
i
f
y
i
n
g
r
u
l
e
s
3
]
;
O
u
t
[
]
=
{
B
A
A
A
C
C
A
A
C
C
B
,
A
C
B
B
A
B
C
,
A
C
C
B
B
A
A
C
A
B
C
C
A
}
I
n
[
]
:
=
R
e
s
o
u
r
c
e
F
u
n
c
t
i
o
n
[
"
M
u
l
t
i
w
a
y
S
y
s
t
e
m
"
]
[
r
u
l
e
s
,
"
A
B
"
,
2
,
"
S
t
a
t
e
s
G
r
a
p
h
"
]
The Monte-Carlo Tree Search Algorithm with Upper-Confidence Bounds Applied to Trees
The visits association object records how many times a state has been explored. The score association object records the potential to simplification of a state.
HeuristicValue calculates the heuristic value of a state to decide whether or not it should be explored. The possible states next step with the highest heuristic value is explored.
Record updates the score associated with the state as well as the number of times visited.
PlayoutValue calculates the score of a state based on a heuristic informed tree search
MonteCarloValue carries out PlayoutValue multiple times for a state.
I
n
[
]
:
=
v
i
s
i
t
s
=
<
|
"
t
o
t
a
l
"
1
|
>
;
s
c
o
r
e
=
<
|
|
>
;
H
e
u
r
i
s
t
i
c
V
a
l
u
e
[
s
t
a
t
e
_
,
c
_
]
:
=
D
o
[
N
t
=
v
i
s
i
t
s
[
"
t
o
t
a
l
"
]
;
N
i
=
I
f
[
K
e
y
E
x
i
s
t
s
Q
[
v
i
s
i
t
s
,
s
t
a
t
e
]
,
v
i
s
i
t
s
[
s
t
a
t
e
]
,
1
]
;
V
=
I
f
[
K
e
y
E
x
i
s
t
s
Q
[
s
c
o
r
e
,
s
t
a
t
e
]
,
s
c
o
r
e
[
s
t
a
t
e
]
,
1
/
S
t
r
i
n
g
L
e
n
g
t
h
[
s
t
a
t
e
]
]
;
(
*
V
d
e
s
c
r
i
b
e
s
t
h
e
p
o
t
e
n
t
i
a
l
o
f
a
s
t
a
t
e
t
o
l
e
a
d
t
o
s
i
m
p
l
i
f
i
c
a
t
i
o
n
.
I
f
t
h
e
s
t
a
t
e
h
a
s
n
o
t
b
e
e
n
a
s
s
i
g
n
e
d
a
s
c
o
r
e
b
e
f
o
r
e
,
t
a
k
e
V
t
o
b
e
t
h
e
i
n
v
e
r
s
e
o
f
t
h
e
s
t
r
i
n
g
l
e
n
g
t
h
.
*
)
R
e
t
u
r
n
[
I
f
[
V
<
0
.
8
,
V
+
c
*
(
L
o
g
[
N
t
]
/
N
i
)
,
0
]
]
,
(
*
L
o
g
[
N
t
]
/
N
i
i
s
u
s
e
d
s
u
c
h
t
h
a
t
w
h
e
n
N
i
(
t
o
t
a
l
n
u
m
b
e
r
t
h
e
s
t
a
t
e
h
a
s
b
e
e
n
e
x
p
l
o
r
e
d
)
i
s
s
m
a
l
l
r
e
l
a
t
i
v
e
t
o
t
o
t
a
l
e
x
p
l
o
r
a
t
i
o
n
N
t
,
t
h
e
h
e
u
r
i
s
t
i
c
i
s
h
i
g
h
t
o
e
n
c
o
u
r
a
g
e
e
x
p
l
o
r
a
t
i
o
n
.
I
f
V
i
s
g
r
e
a
t
e
r
t
h
a
n
0
.
8
,
i
t
i
s
p
r
o
b
a
b
l
y
a
r
e
a
l
l
y
s
h
o
r
t
s
t
a
t
e
o
r
a
s
t
a
t
e
w
i
t
h
c
l
e
a
r
s
i
m
p
l
i
f
i
c
a
t
i
o
n
r
o
u
t
e
s
.
S
e
t
t
h
e
h
e
u
r
i
s
t
i
c
t
o
0
t
o
s
a
v
e
v
a
l
u
a
b
l
e
r
e
s
o
u
r
c
e
s
t
o
e
x
p
l
o
r
e
o
t
h
e
r
s
t
a
t
e
s
.
*
)
1
]
r
e
c
o
r
d
[
s
t
a
t
e
_
,
v
a
l
u
e
_
]
:
=
D
o
[
v
i
s
i
t
s
[
"
t
o
t
a
l
"
]
+
=
1
;
v
i
s
i
t
s
[
s
t
a
t
e
]
=
I
f
[
K
e
y
E
x
i
s
t
s
Q
[
v
i
s
i
t
s
,
s
t
a
t
e
]
,
v
i
s
i
t
s
[
s
t
a
t
e
]
+
1
,
1
]
;
s
c
o
r
e
[
s
t
a
t
e
]
=
I
f
[
K
e
y
E
x
i
s
t
s
Q
[
s
c
o
r
e
,
s
t
a
t
e
]
,
M
a
x
[
s
c
o
r
e
[
s
t
a
t
e
]
,
v
a
l
u
e
]
,
v
a
l
u
e
]
,
(
*
A
l
w
a
y
s
k
e
e
p
t
h
e
m
a
x
i
m
u
m
s
c
o
r
e
s
i
n
c
e
w
e
c
a
n
a
l
m
o
s
t
e
n
s
u
r
e
t
h
e
a
l
g
o
r
i
t
h
m
t
o
f
o
l
l
o
w
t
h
e
b
e
s
t
p
a
t
h
t
h
a
t
g
a
v
e
t
h
e
h
i
g
h
s
c
o
r
e
.
I
n
p
e
r
f
e
c
t
i
n
f
o
r
m
a
t
i
o
n
g
a
m
e
a
l
g
o
r
i
t
h
m
s
s
u
c
h
a
s
A
l
p
h
a
Z
e
r
o
,
a
p
r
o
b
a
b
i
l
i
s
t
i
c
a
p
p
r
o
a
c
h
(
t
a
k
i
n
g
a
v
e
r
a
g
e
o
f
s
c
o
r
e
s
)
i
s
u
s
e
d
i
n
s
t
e
a
d
s
i
n
c
e
t
h
e
a
d
v
e
r
s
a
r
y
'
s
m
v
e
i
n
t
r
o
d
u
c
e
s
s
o
m
e
u
n
c
e
r
t
a
i
n
t
y
.
M
o
v
e
s
t
h
a
t
c
a
n
l
e
a
d
t
o
g
o
o
d
a
d
v
e
r
s
a
r
y
p
e
r
f
o
r
m
a
n
c
e
a
r
e
e
x
p
l
o
r
e
d
o
f
t
e
n
s
i
n
c
e
t
h
e
a
d
v
e
r
s
a
r
y
w
i
l
l
l
i
k
e
c
h
o
o
s
e
t
h
e
m
o
v
e
,
a
n
d
t
h
i
s
r
e
d
u
c
e
s
t
h
e
s
c
o
r
e
f
o
r
t
h
e
s
t
a
t
e
.
*
)
1
]
P
l
a
y
o
u
t
V
a
l
u
e
[
s
t
a
t
e
_
,
i
t
_
,
t
o
t
i
t
_
,
λ
_
]
:
=
I
f
[
i
t
>
t
o
t
i
t
,
(
*
S
i
n
c
e
s
t
r
i
n
g
m
a
n
i
p
u
l
a
t
i
o
n
i
s
i
n
f
i
n
i
t
e
,
w
e
c
h
o
o
s
e
a
t
e
r
m
i
n
a
t
i
n
g
c
o
n
d
i
t
i
o
n
d
e
s
c
r
i
b
e
d
b
y
a
t
o
t
a
l
r
e
c
u
r
s
i
o
n
d
e
p
t
h
t
o
t
i
t
.
*
)
1
/
S
t
r
i
n
g
L
e
n
g
t
h
[
s
t
a
t
e
]
,
(
*
I
f
t
h
e
s
t
a
t
e
i
s
t
h
e
d
e
e
p
e
s
t
r
e
c
u
r
s
i
o
n
a
l
l
o
w
e
d
,
s
i
m
p
l
y
r
e
t
u
r
n
t
h
e
i
n
v
e
r
s
e
l
e
n
g
t
h
o
f
t
h
e
s
t
r
i
n
g
.
*
)
M
o
d
u
l
e
[
{
v
a
l
u
e
}
,
c
u
r
r
e
n
t
v
a
l
u
e
=
1
/
S
t
r
i
n
g
L
e
n
g
t
h
[
s
t
a
t
e
]
;
(
*
I
n
v
e
r
s
e
o
f
s
t
r
i
n
g
l
e
n
g
t
h
i
s
t
h
e
m
i
n
i
m
u
m
v
a
l
u
e
o
f
t
h
e
s
t
a
t
e
.
I
f
s
i
m
p
l
i
f
i
c
a
t
i
o
n
r
o
u
t
e
s
e
x
i
s
t
,
t
h
e
v
a
l
u
e
c
a
n
b
e
e
v
e
n
h
i
g
h
e
r
*
)
n
e
x
t
s
t
a
t
e
s
=
L
a
s
t
[
R
e
s
o
u
r
c
e
F
u
n
c
t
i
o
n
[
"
M
u
l
t
i
w
a
y
S
y
s
t
e
m
"
]
[
r
u
l
e
s
,
s
t
a
t
e
,
1
]
]
;
l
e
n
g
t
h
=
L
e
n
g
t
h
[
n
e
x
t
s
t
a
t
e
s
]
;
h
e
u
r
i
s
t
i
c
t
a
b
l
e
=
T
a
b
l
e
[
H
e
u
r
i
s
t
i
c
V
a
l
u
e
[
n
e
x
t
s
t
a
t
e
s
[
[
a
]
]
,
0
.
0
5
]
,
{
a
,
1
,
l
e
n
g
t
h
,
1
}
]
;
p
o
s
i
t
i
o
n
t
a
b
l
e
=
P
o
s
i
t
i
o
n
[
h
e
u
r
i
s
t
i
c
t
a
b
l
e
,
M
a
x
[
h
e
u
r
i
s
t
i
c
t
a
b
l
e
]
]
;
b
e
s
t
p
o
s
i
t
i
o
n
=
p
o
s
i
t
i
o
n
t
a
b
l
e
[
[
R
a
n
d
o
m
I
n
t
e
g
e
r
[
{
1
,
L
e
n
g
t
h
[
p
o
s
i
t
i
o
n
t
a
b
l
e
]
}
]
]
]
;
n
e
w
s
t
a
t
e
=
n
e
x
t
s
t
a
t
e
s
[
[
b
e
s
t
p
o
s
i
t
i
o
n
]
]
[
[
1
]
]
;
v
a
l
u
e
=
M
a
x
[
c
u
r
r
e
n
t
v
a
l
u
e
,
λ
*
P
l
a
y
o
u
t
V
a
l
u
e
[
n
e
w
s
t
a
t
e
,
i
t
+
1
,
t
o
t
i
t
,
λ
]
]
;
(
*
T
h
e
v
a
l
u
e
i
s
s
e
l
e
t
e
d
a
s
t
h
e
m
a
x
i
m
u
m
b
e
t
w
e
e
n
t
h
e
v
a
l
u
e
o
f
d
u
e
t
o
t
h
e
l
e
n
g
t
h
o
f
t
h
e
s
t
a
t
e
i
t
s
e
l
f
a
n
d
t
h
e
f
o
u
n
d
p
a
t
h
t
h
a
t
m
i
g
h
t
l
e
a
d
t
o
s
i
m
p
l
i
f
i
c
a
t
i
o
n
.
*
)
r
e
c
o
r
d
[
s
t
a
t
e
,
v
a
l
u
e
]
;
v
a
l
u
e
]
]
M
o
n
t
e
C
a
r
l
o
V
a
l
u
e
[
s
t
a
t
e
_
,
m
_
,
n
_
]
:
=
M
a
x
[
T
a
b
l
e
[
P
l
a
y
o
u
t
V
a
l
u
e
[
s
t
a
t
e
,
0
,
m
,
0
.
9
8
]
,
{
i
,
0
,
n
,
1
}
]
]
Training
The training takes quite some time. If you want to run the notebook without the training, run the cells in subsection “Training Results” to initialize the variables containing the results. No need to expand the cells as they are very long. Collect scores by running PlayoutValue for randomized initial strings of various lengths. Short length initial states require less iterations to find full simplification and also has less possible outcomes to exhaust. The string length the procedure is working on is printed. We start from length 5 strings and move to length 20 strings eventually. The training might take a few minutes and takes longer as string lengths increase.
I
n
[
]
:
=
n
=
5
;
W
h
i
l
e
[
n
<
2
0
,
n
+
=
1
;
P
r
i
n
t
[
n
]
;
m
=
0
;
W
h
i
l
e
[
m
<
5
0
0
;
m
+
=
1
;
M
o
n
t
e
C
a
r
l
o
V
a
l
u
e
[
R
e
s
o
u
r
c
e
F
u
n
c
t
i
o
n
[
"
R
a
n
d
o
m
S
t
r
i
n
g
"
]
[
{
"
A
"
,
"
B
"
,
"
C
"
}
,
n
]
,
8
*
n
,
8
*
n
]
;
]
;
]
6
7
O
u
t
[
]
=
$
A
b
o
r
t
e
d
Save the status of training.
I
n
[
]
:
=
S
a
v
e
[
"
v
i
s
i
t
s
.
m
"
,
v
i
s
i
t
s
]
;
S
a
v
e
[
"
s
c
o
r
e
.
m
"
,
s
c
o
r
e
]
;
I
n
[
]
:
=
v
i
s
i
t
s
=
I
m
p
o
r
t
[
"
v
i
s
i
t
s
.
m
"
]
;
s
c
o
r
e
=
I
m
p
o
r
t
[
"
s
c
o
r
e
.
m
"
]
;
Simplification Algorithm
FindShortestString uses the training results and the scores of states to optimize finding simplification routes. If mode==”Optimized”, the scores for states trained with MCTS is used. Else, only string lengths are used to search the tree.
t
a
b
l
e
o
f
u
s
e
d
r
u
l
e
s
=
T
a
b
l
e
[
0
,
{
i
,
1
,
L
e
n
g
t
h
[
r
u
l
e
s
]
,
1
}
]
;
(
*
T
h
i
s
t
a
b
l
e
c
o
u
n
t
s
h
o
w
m
a
n
y
t
i
m
e
s
a
r
u
l
e
h
a
s
b
e
e
n
u
s
e
d
d
u
r
i
n
g
s
i
m
p
l
i
f
i
c
a
t
i
o
n
.
*
)
I
n
[
]
:
=
S
t
a
t
e
T
o
S
c
o
r
e
[
s
t
a
t
e
_
]
:
=
I
f
[
K
e
y
E
x
i
s
t
s
Q
[
s
c
o
r
e
,
s
t
a
t
e
]
,
s
c
o
r
e
[
s
t
a
t
e
]
,
1
/
S
t
r
i
n
g
L
e
n
g
t
h
[
s
t
a
t
e
]
]
(
*
F
u
n
c
t
i
o
n
t
h
a
t
c
o
m
p
u
t
e
s
t
h
e
s
c
o
r
e
o
f
a
s
t
a
t
e
b
a
s
e
d
o
n
l
e
n
g
t
h
o
r
s
i
m
p
l
i
c
a
t
i
o
n
p
o
t
e
n
t
i
a
l
.
*
)
S
t
a
t
e
T
o
S
c
o
r
e
U
n
o
p
t
i
m
i
z
e
d
[
s
t
a
t
e
_
]
:
=
I
f
[
K
e
y
E
x
i
s
t
s
Q
[
s
c
o
r
e
,
s
t
a
t
e
]
,
s
c
o
r
e
[
s
t
a
t
e
]
,
1
/
S
t
r
i
n
g
L
e
n
g
t
h
[
s
t
a
t
e
]
]
(
*
L
e
n
g
t
h
b
a
s
e
d
o
n
l
y
s
c
o
r
e
c
o
m
p
u
t
a
t
i
o
n
.
*
)
F
i
n
d
S
h
o
r
t
e
s
t
S
t
r
i
n
g
[
s
t
r
i
n
g
_
,
m
o
d
e
_
]
:
=
M
o
d
u
l
e
[
{
c
u
r
r
e
n
t
s
t
r
i
n
g
,
n
e
w
s
t
a
t
e
=
s
t
r
i
n
g
,
n
e
x
t
s
c
o
r
e
=
1
/
S
t
r
i
n
g
L
e
n
g
t
h
[
s
t
r
i
n
g
]
,
c
u
r
r
e
n
t
s
c
o
r
e
=
0
}
,
W
h
i
l
e
[
n
e
x
t
s
c
o
r
e
>
c
u
r
r
e
n
t
s
c
o
r
e
,
(
*
T
h
e
l
o
o
p
t
e
r
m
i
n
a
t
e
s
w
h
e
n
t
h
e
s
c
o
r
e
o
f
t
h
e
c
u
r
r
e
n
t
s
t
r
i
n
g
i
s
l
a
r
g
e
r
t
h
a
n
a
l
l
p
o
s
s
i
b
l
e
c
h
i
l
d
r
e
n
i
n
t
w
o
g
e
n
e
r
a
t
i
o
n
s
.
*
)
P
r
i
n
t
[
c
u
r
r
e
n
t
s
t
r
i
n
g
]
;
c
u
r
r
e
n
t
s
c
o
r
e
=
n
e
x
t
s
c
o
r
e
;
c
u
r
r
e
n
t
s
t
r
i
n
g
=
n
e
w
s
t
a
t
e
;
f
i
r
s
t
l
a
y
e
r
=
T
a
b
l
e
[
L
a
s
t
[
R
e
s
o
u
r
c
e
F
u
n
c
t
i
o
n
[
"
M
u
l
t
i
w
a
y
S
y
s
t
e
m
"
]
[
r
u
l
e
s
[
[
r
u
l
e
]
]
,
c
u
r
r
e
n
t
s
t
r
i
n
g
,
1
,
"
P
r
e
d
e
c
e
s
s
o
r
R
u
l
e
s
L
i
s
t
"
]
]
,
{
r
u
l
e
,
1
,
L
e
n
g
t
h
[
r
u
l
e
s
]
,
1
}
]
;
(
*
R
e
t
u
r
n
s
a
l
i
s
t
o
f
c
h
i
l
d
r
e
n
a
n
d
t
h
e
i
r
p
a
r
e
n
t
s
.
T
h
e
t
a
b
l
e
i
s
s
t
r
u
c
t
u
r
e
d
s
u
c
h
t
h
a
t
c
h
i
l
d
r
e
n
b
y
a
p
p
l
i
c
a
t
i
o
n
o
f
d
i
f
f
e
r
e
n
t
r
u
l
e
s
a
r
e
p
u
t
i
n
d
i
f
f
e
r
e
n
t
e
l
e
m
e
n
t
s
.
S
u
c
h
a
s
t
r
u
c
u
t
r
e
i
s
h
e
l
p
f
u
l
w
h
e
n
f
i
g
u
r
i
n
g
o
u
t
w
h
i
c
h
r
u
l
e
s
a
r
e
u
s
e
d
f
o
r
s
i
m
p
l
i
f
i
c
a
t
i
o
n
.
*
)
f
i
r
s
t
l
a
y
e
r
s
t
a
t
e
s
=
T
a
b
l
e
[
T
a
b
l
e
[
f
i
r
s
t
l
a
y
e
r
[
[
r
u
l
e
]
]
[
[
s
t
a
t
e
]
]
[
[
1
]
]
,
{
s
t
a
t
e
,
1
,
L
e
n
g
t
h
[
f
i
r
s
t
l
a
y
e
r
[
[
r
u
l
e
]
]
]
,
1
}
]
,
{
r
u
l
e
,
1
,
L
e
n
g
t
h
[
r
u
l
e
s
]
,
1
}
]
;
(
*
R
e
m
o
v
e
t
h
e
p
a
r
e
n
t
s
.
*
)
f
i
r
s
t
l
a
y
e
r
s
c
o
r
e
s
=
I
f
[
m
o
d
e
=
=
"
O
p
t
i
m
i
z
e
d
"
,
M
a
p
[
S
t
a
t
e
T
o
S
c
o
r
e
,
f
i
r
s
t
l
a
y
e
r
s
t
a
t
e
s
,
{
2
}
]
,
S
t
a
t
e
T
o
S
c
o
r
e
U
n
o
p
t
i
m
i
z
e
d
/
@
f
i
r
s
t
l
a
y
e
r
s
t
a
t
e
s
]
;
(
*
C
o
m
p
u
t
e
t
h
e
s
c
o
r
e
o
f
c
h
i
l
d
r
e
n
w
i
t
h
o
u
t
c
h
a
n
g
i
n
g
t
h
e
s
t
r
u
c
t
u
r
e
.
S
c
o
r
e
s
a
f
t
e
r
d
i
f
f
e
r
e
n
t
r
u
l
e
s
a
r
e
i
n
d
i
f
f
e
r
e
n
t
e
l
e
m
e
n
t
s
.
*
)
f
i
r
s
t
l
a
y
e
r
m
a
x
s
c
o
r
e
=
M
a
x
[
f
i
r
s
t
l
a
y
e
r
s
c
o
r
e
s
]
;
(
*
M
a
x
i
m
u
m
s
c
o
r
e
o
f
g
e
n
e
r
a
t
i
o
n
o
n
e
c
h
i
l
d
r
e
n
.
*
)
s
e
c
o
n
d
l
a
y
e
r
=
T
a
b
l
e
[
T
a
b
l
e
[
T
a
b
l
e
[
L
a
s
t
[
R
e
s
o
u
r
c
e
F
u
n
c
t
i
o
n
[
"
M
u
l
t
i
w
a
y
S
y
s
t
e
m
"
]
[
r
u
l
e
s
[
[
s
e
c
o
n
d
r
u
l
e
]
]
,
f
i
r
s
t
l
a
y
e
r
[
[
r
u
l
e
]
]
[
[
s
t
a
t
e
]
]
[
[
1
]
]
,
1
,
"
P
r
e
d
e
c
e
s
s
o
r
R
u
l
e
s
L
i
s
t
"
]
]
,
{
s
t
a
t
e
,
1
,
L
e
n
g
t
h
[
f
i
r
s
t
l
a
y
e
r
[
[
r
u
l
e
]
]
]
,
1
}
]
,
{
r
u
l
e
,
1
,
L
e
n
g
t
h
[
r
u
l
e
s
]
,
1
}
]
,
{
s
e
c
o
n
d
r
u
l
e
,
1
,
L
e
n
g
t
h
[
r
u
l
e
s
]
,
1
}
]
;
(
*
R
e
t
u
r
n
s
c
h
i
l
d
r
e
n
o
f
e
a
c
h
f
i
r
s
t
g
e
n
e
r
a
t
i
o
n
c
h
i
l
d
r
e
n
.
E
a
c
h
e
l
e
m
e
n
t
s
t
i
l
l
c
o
r
r
e
s
p
o
n
d
t
o
t
h
e
f
i
r
s
t
a
p
p
l
i
e
d
r
u
l
e
s
,
a
n
d
t
h
e
n
e
x
t
l
e
v
e
l
i
s
s
e
p
a
r
a
t
e
d
b
y
s
e
c
o
n
d
a
p
p
l
i
e
d
r
u
l
e
s
.
S
u
c
h
a
s
t
r
u
c
u
t
r
e
i
s
h
e
l
p
f
u
l
w
h
e
n
f
i
g
u
r
i
n
g
o
u
t
w
h
i
c
h
r
u
l
e
s
a
r
e
u
s
e
d
f
o
r
s
i
m
p
l
i
f
i
c
a
t
i
o
n
.
*
)
s
e
c
o
n
d
l
a
y
e
r
s
t
a
t
e
s
=
T
a
b
l
e
[
T
a
b
l
e
[
T
a
b
l
e
[
T
a
b
l
e
[
s
e
c
o
n
d
l
a
y
e
r
[
[
s
e
c
o
n
d
r
u
l
e
]
]
[
[
r
u
l
e
]
]
[
[
s
e
c
o
n
d
s
t
a
t
e
]
]
[
[
s
t
a
t
e
]
]
[
[
1
]
]
,
{
s
t
a
t
e
,
1
,
L
e
n
g
t
h
[
s
e
c
o
n
d
l
a
y
e
r
[
[
s
e
c
o
n
d
r
u
l
e
]
]
[
[
r
u
l
e
]
]
[
[
s
e
c
o
n
d
s
t
a
t
e
]
]
]
,
1
}
]
,
{
s
e
c
o
n
d
s
t
a
t
e
,
1
,
L
e
n
g
t
h
[
s
e
c
o
n
d
l
a
y
e
r
[
[
s
e
c
o
n
d
r
u
l
e
]
]
[
[
r
u
l
e
]
]
]
,
1
}
]
,
{
r
u
l
e
,
1
,
L
e
n
g
t
h
[
r
u
l
e
s
]
,
1
}
]
,
{
s
e
c
o
n
d
r
u
l
e
,
1
,
L
e
n
g
t
h
[
r
u
l
e
s
]
,
1
}
]
;
s
e
c
o
n
d
l
a
y
e
r
s
c
o
r
e
s
=
I
f
[
m
o
d
e
=
=
"
O
p
t
i
m
i
z
e
d
"
,
M
a
p
[
S
t
a
t
e
T
o
S
c
o
r
e
,
s
e
c
o
n
d
l
a
y
e
r
s
t
a
t
e
s
,
{
4
}
]
,
S
t
a
t
e
T
o
S
c
o
r
e
U
n
o
p
t
i
m
i
z
e
d
/
@
s
e
c
o
n
d
l
a
y
e
r
s
t
a
t
e
s
]
;
s
e
c
o
n
d
l
a
y
e
r
m
a
x
s
c
o
r
e
=
M
a
x
[
s
e
c
o
n
d
l
a
y
e
r
s
c
o
r
e
s
]
;
(
*
T
h
e
h
i
g
h
e
s
t
s
c
o
r
e
a
m
o
n
g
a
l
l
c
h
i
l
d
r
e
n
*
)
I
f
[
f
i
r
s
t
l
a
y
e
r
m
a
x
s
c
o
r
e
>
s
e
c
o
n
d
l
a
y
e
r
m
a
x
s
c
o
r
e
,
(
*
C
h
o
o
s
e
t
h
e
b
e
s
t
s
t
r
i
n
g
f
r
o
m
f
i
r
s
t
g
e
n
e
r
a
t
i
o
n
c
h
i
l
d
r
e
n
i
f
t
h
e
f
i
r
s
t
l
a
y
e
r
h
a
s
t
h
e
b
e
s
t
s
c
o
r
e
*
)
D
o
[
p
o
s
i
t
i
o
n
t
a
b
l
e
=
P
o
s
i
t
i
o
n
[
f
i
r
s
t
l
a
y
e
r
s
c
o
r
e
s
,
f
i
r
s
t
l
a
y
e
r
m
a
x
s
c
o
r
e
]
;
b
e
s
t
p
o
s
i
t
i
o
n
=
p
o
s
i
t
i
o
n
t
a
b
l
e
[
[
R
a
n
d
o
m
I
n
t
e
g
e
r
[
{
1
,
L
e
n
g
t
h
[
p
o
s
i
t
i
o
n
t
a
b
l
e
]
}
]
]
]
;
r
u
l
e
=
b
e
s
t
p
o
s
i
t
i
o
n
[
[
1
]
]
;
I
f
[
m
o
d
e
"
O
p
t
i
m
i
z
e
d
"
,
D
o
[
t
a
b
l
e
o
f
u
s
e
d
r
u
l
e
s
[
[
r
u
l
e
]
]
+
=
1
,
1
]
,
S
k
i
p
]
;
s
t
a
t
e
p
o
s
i
t
i
o
n
=
b
e
s
t
p
o
s
i
t
i
o
n
[
[
2
]
]
;
n
e
w
s
t
a
t
e
=
f
i
r
s
t
l
a
y
e
r
s
t
a
t
e
s
[
[
r
u
l
e
]
]
[
[
s
t
a
t
e
p
o
s
i
t
i
o
n
]
]
,
1
]
,
(
*
C
h
o
o
s
e
t
h
e
b
e
s
t
s
t
r
i
n
g
f
r
o
m
s
e
c
o
n
d
g
e
n
e
r
a
t
i
o
n
c
h
i
l
d
r
e
n
i
f
t
h
e
s
e
c
o
n
d
l
a
y
e
r
h
a
s
t
h
e
b
e
s
t
s
c
o
r
e
*
)
D
o
[
p
o
s
i
t
i
o
n
t
a
b
l
e
=
P
o
s
i
t
i
o
n
[
s
e
c
o
n
d
l
a
y
e
r
s
c
o
r
e
s
,
s
e
c
o
n
d
l
a
y
e
r
m
a
x
s
c
o
r
e
]
;
b
e
s
t
p
o
s
i
t
i
o
n
=
p
o
s
i
t
i
o
n
t
a
b
l
e
[
[
R
a
n
d
o
m
I
n
t
e
g
e
r
[
{
1
,
L
e
n
g
t
h
[
p
o
s
i
t
i
o
n
t
a
b
l
e
]
}
]
]
]
;
s
e
c
o
n
d
r
u
l
e
=
b
e
s
t
p
o
s
i
t
i
o
n
[
[
1
]
]
;
r
u
l
e
=
b
e
s
t
p
o
s
i
t
i
o
n
[
[
2
]
]
;
(
*
O
n
l
y
u
p
d
a
t
e
t
a
b
l
e
o
f
r
u
l
e
s
i
f
u
s
i
n
g
M
C
T
S
*
)
I
f
[
m
o
d
e
"
O
p
t
i
m
i
z
e
d
"
,
D
o
[
t
a
b
l
e
o
f
u
s
e
d
r
u
l
e
s
[
[
s
e
c
o
n
d
r
u
l
e
]
]
+
=
1
;
t
a
b
l
e
o
f
u
s
e
d
r
u
l
e
s
[
[
r
u
l
e
]
]
+
=
1
,
1
]
,
S
k
i
p
]
;
s
e
c
o
n
d
s
t
a
t
e
p
o
s
i
t
i
o
n
=
b
e
s
t
p
o
s
i
t
i
o
n
[
[
3
]
]
;
s
t
a
t
e
p
o
s
i
t
i
o
n
=
b
e
s
t
p
o
s
i
t
i
o
n
[
[
4
]
]
;
n
e
w
s
t
a
t
e
=
s
e
c
o
n
d
l
a
y
e
r
s
t
a
t
e
s
[
[
s
e
c
o
n
d
r
u
l
e
]
]
[
[
r
u
l
e
]
]
[
[
s
e
c
o
n
d
s
t
a
t
e
p
o
s
i
t
i
o
n
]
]
[
[
s
t
a
t
e
p
o
s
i
t
i
o
n
]
]
;
(
*
C
h
i
l
d
s
t
r
i
n
g
w
i
t
h
t
h
e
b
e
s
t
s
c
o
r
e
*
)
,
1
]
]
;
n
e
x
t
s
c
o
r
e
=
M
a
x
[
f
i
r
s
t
l
a
y
e
r
m
a
x
s
c
o
r
e
,
s
e
c
o
n
d
l
a
y
e
r
m
a
x
s
c
o
r
e
]
;
]
;
P
r
i
n
t
[
c
u
r
r
e
n
t
s
t
r
i
n
g
]
;
(
*
W
h
e
n
a
l
l
c
h
i
l
d
r
e
n
h
a
v
e
l
o
w
e
r
s
c
o
r
e
s
t
h
a
n
t
h
e
p
a
r
e
n
t
,
p
r
i
n
t
t
h
e
p
a
r
e
n
t
a
s
t
h
e
e
n
d
r
e
s
u
l
t
.
*
)
]
Testing all algorithms.
I
n
[
]
:
=
s
t
r
i
n
g
=
R
e
s
o
u
r
c
e
F
u
n
c
t
i
o
n
[
"
R
a
n
d
o
m
S
t
r
i
n
g
"
]
[
{
"
A
"
,
"
B
"
,
"
C
"
}
,
1
5
]
;
P
r
i
n
t
[
"
O
p
t
i
m
i
z
e
d
M
C
T
S
t
r
e
e
s
e
a
r
c
h
s
o
l
u
t
i
o
n
"
]
F
i
n
d
S
h
o
r
t
e
s
t
S
t
r
i
n
g
[
s
t
r
i
n
g
,
"
O
p
t
i
m
i
z
e
d
"
]
P
r
i
n
t
[
"
U
n
o
p
t
i
m
i
z
e
d
t
r
e
e
s
e
a
r
c
h
s
o
l
u
t
i
o
n
"
]
F
i
n
d
S
h
o
r
t
e
s
t
S
t
r
i
n
g
[
s
t
r
i
n
g
,
"
n
o
t
o
p
t
i
m
i
z
e
d
"
]
P
r
i
n
t
[
"
B
r
u
t
e
-
f
o
r
c
e
s
o
l
u
t
i
o
n
s
"
]
n
a
i
v
e
b
r
u
t
e
f
o
r
c
e
s
t
a
t
e
s
=
F
l
a
t
t
e
n
[
R
e
s
o
u
r
c
e
F
u
n
c
t
i
o
n
[
"
M
u
l
t
i
w
a
y
S
y
s
t
e
m
"
]
[
s
i
m
p
l
i
f
y
i
n
g
r
u
l
e
s
,
s
t
r
i
n
g
,
2
0
]
]
;
s
t
r
i
n
g
l
e
n
g
t
h
s
=
S
t
r
i
n
g
L
e
n
g
t
h
[
n
a
i
v
e
b
r
u
t
e
f
o
r
c
e
s
t
a
t
e
s
]
;
n
a
i
v
e
b
r
u
t
e
f
o
r
c
e
s
t
a
t
e
s
[
[
P
o
s
i
t
i
o
n
[
s
t
r
i
n
g
l
e
n
g
t
h
s
,
M
i
n
[
s
t
r
i
n
g
l
e
n
g
t
h
s
]
]
[
[
1
]
]
[
[
1
]
]
]
]
O
p
t
i
m
i
z
e
d
M
C
T
S
t
r
e
e
s
e
a
r
c
h
s
o
l
u
t
i
o
n
c
u
r
r
e
n
t
s
t
r
i
n
g
$
5
8
8
3
3
7
1
C
A
C
C
C
C
C
B
B
B
A
A
B
C
B
C
A
C
C
C
C
C
B
C
C
B
A
A
C
C
C
C
B
C
C
A
A
B
C
C
A
A
U
n
o
p
t
i
m
i
z
e
d
t
r
e
e
s
e
a
r
c
h
s
o
l
u
t
i
o
n
c
u
r
r
e
n
t
s
t
r
i
n
g
$
5
9
1
1
6
6
8
C
A
C
C
C
C
C
B
B
B
A
A
B
C
B
C
A
C
C
C
C
C
B
A
C
B
C
A
C
B
A
C
B
C
A
C
A
C
B
r
u
t
e
-
f
o
r
c
e
s
o
l
u
t
i
o
n
s
O
u
t
[
]
=
C
A
C
C
C
C
C
It is clear that The MCTS algorithm is superior in that it simplifies the string to the fullest extent. The string length only tree search algorithm came in second place, and the brute force solution with simplifying rules only is the worst. Full tree search without the complete set of rules is not even feasible to compute.
If we want to see what rules are implemented most frequently, we can run the MCTS algorithm multiple times and examine the table of the frequency of rule usage.
I
n
[
]
:
=
D
o
[
s
t
r
i
n
g
=
R
e
s
o
u
r
c
e
F
u
n
c
t
i
o
n
[
"
R
a
n
d
o
m
S
t
r
i
n
g
"
]
[
{
"
A
"
,
"
B
"
,
"
C
"
}
,
1
5
]
;
B
l
o
c
k
[
{
P
r
i
n
t
}
,
F
i
n
d
S
h
o
r
t
e
s
t
S
t
r
i
n
g
[
s
t
r
i
n
g
,
"
O
p
t
i
m
i
z
e
d
"
]
]
,
1
0
0
]
;
t
a
b
l
e
o
f
u
s
e
d
r
u
l
e
s
O
u
t
[
]
=
{
6
5
,
7
0
,
8
2
,
8
,
2
2
,
1
9
,
2
0
6
,
2
0
,
4
,
1
9
,
3
1
,
3
0
,
5
8
,
7
5
,
4
3
,
1
,
6
,
1
1
,
1
2
5
,
2
2
,
7
,
3
,
1
5
,
2
9
,
1
5
,
6
5
,
5
,
2
2
7
,
4
,
2
5
,
1
,
1
,
0
,
1
2
,
0
,
1
}
I
n
[
]
:
=
T
a
b
l
e
[
r
u
l
e
s
[
[
r
u
l
e
]
]
t
a
b
l
e
o
f
u
s
e
d
r
u
l
e
s
[
[
r
u
l
e
]
]
,
{
r
u
l
e
,
1
,
L
e
n
g
t
h
[
r
u
l
e
s
]
,
1
}
]
O
u
t
[
]
=
{
(
A
A
B
)
6
5
,
(
A
B
B
A
A
)
7
0
,
(
B
A
A
B
B
B
)
8
2
,
(
A
B
A
B
B
A
A
)
8
,
(
A
A
A
B
A
)
2
2
,
(
B
A
B
B
B
B
)
1
9
,
(
A
B
A
)
2
0
6
,
(
A
A
B
B
A
)
2
0
,
(
B
B
B
A
A
B
)
4
,
(
B
A
A
A
B
A
B
)
1
9
,
(
A
B
A
A
A
)
3
1
,
(
B
B
B
B
B
A
)
3
0
,
(
C
C
B
)
5
8
,
(
C
B
B
C
C
)
7
5
,
(
B
C
C
B
B
B
)
4
3
,
(
C
B
C
B
B
C
C
)
1
,
(
C
C
C
B
C
)
6
,
(
B
C
B
B
B
B
)
1
1
,
(
C
B
C
)
1
2
5
,
(
C
C
B
B
C
)
2
2
,
(
B
B
B
C
C
B
)
7
,
(
B
C
C
C
B
C
B
)
3
,
(
C
B
C
C
C
)
1
5
,
(
B
B
B
B
B
C
)
2
9
,
(
A
A
C
C
)
1
5
,
(
A
A
C
C
A
C
C
)
6
5
,
(
C
C
A
A
A
A
A
A
C
)
5
,
(
A
C
C
A
)
2
2
7
,
(
C
A
C
C
A
A
C
)
4
,
(
A
A
A
A
C
C
C
A
A
)
2
5
,
(
A
B
C
A
C
B
B
)
1
,
(
B
A
A
A
C
C
A
A
C
C
B
)
1
,
(
A
B
C
C
A
A
C
C
B
B
A
A
C
)
0
,
(
A
C
B
B
A
B
C
)
1
2
,
(
A
A
C
C
B
B
A
A
A
C
C
)
0
,
(
A
C
C
B
B
A
A
C
A
B
C
C
A
)
1
}
Some notable example rules are (A
AB)
65, (AAC
CACC)
65, (C
CB)
58, (AA
ABA)
22, (BA
BBBB)
19, (A
ABBA)
20, (BAA
ABAB)
19, (C
CBBC)
22. These rules increases the complexity on the surface, but are called many times to lead to further simplification. In the future, with causal graphs, we can systematically examine the causal relationship between these rules and further simplification rules.
T
r
a
i
n
i
n
g
R
e
s
u
l
t
s
N
e
u
r
a
l
N
e
t
w
o
r
k
H
e
u
r
i
s
t
i
c
(
w
o
r
k
i
n
p
r
o
g
r
e
s
s
)
POSTED BY:
Minzhao (Henry) Liu
Answer
Mark as an Answer
Reply
|
Flag
Reply to this discussion
in reply to
Add Notebook
Community posts can be styled and formatted using the
Markdown syntax
.
Tag limit exceeded
Note: Only the first five people you tag will receive an email notification; the other tagged names will appear as links to their profiles.
Publish anyway
Cancel
Reply Preview
Attachments
Remove
Add a file to this post
Follow this discussion
or
Discard
Group Abstract
Be respectful. Review our
Community Guidelines
to understand your role and responsibilities.
Community Terms of Use
Feedback
Enable JavaScript to interact with content and submit forms on Wolfram websites.
Learn how »