AML is a language that allows you to create a nucleus, using the building rules defined by Miles Mathis, all the way down to the protons, neutrons and electrons. Yet it provides a simplicity that allows you to create structures with ease. While it is possible to define a proton stack by specifying every single proton, neutron and electron, you can also create a basic stack of the same size in just 2 characters. This allows you to start with basic constructs until you have the main structure, making rapid changes easily, then focus on specific areas by specifying the particle chains directly.
There are effectively 5 layers to an AML expression. From bottom to top, they are:
The bottom layers handle particles, while the top layers handle atoms. The middle layer provides the linking mechanism that brings a nucleus together.
There are 3 particles that you can use to build with: protons, neutrons and electrons. Each of them is declared by their first letter: P, N and E. The particle type can be followed by an integer, between 1 and 6 inclusive, that specifies how many particles you want to use. If a number is not specified, it will default to 1.
We can link particles together into a chain in order to create proton stacks and neutron groups. There are limitations to how various particles relate to each other and you must be careful to get meaningful results.
In order to create a particle chain, you use the connect operator : to connect particles together. For example, if we wanted to create a proton stack with 2 neutrons between 2 protons, we connect them like this:
The stack is arranged from bottom to top, so we start with a proton, then a level containing 2 neutrons, and a proton on top. Notice that we specified N2 to create a single layer of neutrons. If we used two distinct neutrons instead:
we would get a very different result. Each connect operator : creates a new level, so by separating the neutrons, 2 levels are created. Electrons are the same.
The proton does not work in the same way, though. A proton will always create a new level, even if declared with a number. Protons can only stack one way, but neutrons and electrons can be used in groups that arrange them into the plane orthogonal to the direction of the stack.
This does allow us to use some shortcuts when working with protons. Say we wanted to create 2 stacks like we created above. We could do it the long way:
or we could make it a little bit shorter by bringing those middle protons, P:P, together into a P2 declaration:
This shorthand is more useful with odd-sized stacks, since we can group the protons without neutrons together:
Electrons must be bound to a proton. At least one side of it must connect to a proton, but the other side may connect to any other particle, even another electron. It is possible to put electrons on the inside of a stack, even though this is generally not done. You will usually find them on the start and end of a stack declaration, such as this:
but may find them inside on special occasions.
It is really good to be able to declare a proton stack with such precision, but most of the time we don't really need to be so expressive. So the basic stack can be used to quickly declare a stack containing a specified number of protons. You do this by using the S type prefix, followed by the number of protons in the stack. You will also get an even number of neutrons, arranged so that the stack is built from as many P:N2:P constructs as possible.
The arrangement of neutrons within a stack depends on the number of neutrons in the group. If you only have a single neutron, it will be placed at the center and take up the same space, along the stack axis, as a proton. You can use this to put a neutron on the end of a proton stack, but it is discouraged. There are better ways to accomplish the same thing, but they are more descriptive to an application using your AML expression, which allows them to provide more functionality based on it.
When you have multiple neutrons together, they are considered a neutron group and behave differently to a single neutron. The neutrons will be arranged in a circle around the proton stacks axis. They will also take up much less space along that axis because they are further out into the charge emission of the surrounding protons in the stack.
Here we have all 6 neutron arrangements, looking down from above the stack:
To see the space the neutrons take up, we can compare a proton stack with and without neutrons in it:
Electrons behave much like neutrons. Electron groups, E2 to E6, will be arranged about the stack axis just like neutron groups, although they are placed much closer to the center of the stack because they are meant to be circling around the protons pole.
A single electron, though, will not be put at the center of the stack, it will behave just like the electron groups, moving a little bit out from the center. So there is no difference between a single electron and an electron group, it is just an electron group with 1 item in it.
Electron groups do not take up any space along the stack axis. They are meant to be attached to the proton and not a part of the stack structure, so they can not change the height of it by their presence alone.
The following image shows each electron group, arranged above a proton, with the camera looking in from the side:
Now that we can build a stack of particles, we can join them together by chaining a series of stacks. Each alternate stack is rotated 90° so that one emits into the pole of the other. The - operator is used between stacks to link them into a nuclear chain.
We can use either a fully qualified particle chain, or a basic stack in the same chain.
We now have enough constructs to create an atom. All we need is to impose a little structure using the building blocks that we have. We start with the core of an atom. This is a single proton stack which can be declared using a basic stack or a constructed stack of particles. Around this core stack, we can arrange up to 6 nuclear chains, all pointing away from the core stack.
The first 2 chains can be put onto the top and bottom of the core. This arranges the chains such that they emit into the core. We call these the axial level.
The next 4 chains can be placed around the core and are called the carousel level. The first stack in a carousel chain is receiving charge from the core of the atom.
To declare an atom, we start with the core stack:
then we add in pillars and caps:
Each level is contained with < and >. A level must specify its type as the first token. The above AML expression uses the full Axial keyword, but just A is enough. Similarly, you can create carousel chains by using the Carousel or C keywords.
There are 3 more level types that can be used that allow you to specify the dimension on which 1 or 2 nuclear chains can be placed. Use X, Y, or Z
Each atomic level, Axial and Carousel or X, Y and Z, has a comma separated list of nuclear chains. All of them can accept 2 chains, but the Carousel level can accept 4. The order of the nuclear chains is positive then negative. For the Carousel level, it is +X, -X, +Z, -Z, and is equivalent to <X +, -> <Z +, ->. So the Axial or Y levels can set the North and South positions, while the Carousel can set the East, West, Front and Back positions. The X level sets the East and West while the Z level sets the Front and Back.
Some elements need to place some stacks that are bonded to the pillar stacks, which are the first stacks in each chain of the axial level. These can be placed after the stack that they are bonded to using the attachment operators [ and ].
Each attachment can contain 1 or 2 stacks with the first one placed in the positive X in the north and negative X in the south. The second stack is placed on the other side, so negative X in the north and postive X in the south. If you don't want a stack in the first position but do in the second, then use the null operator _ in the first position.
The largest of atoms are not really atoms, and could be thought of as molecules. However, they are on the periodic table, so we continue to call them atoms. Therefore, AML must support them. Since the nuclear structure is so different from the rest of the elements, we must treat them as a special entity. This introduces a fifth level to our language.
What we need to do is define multiple atoms and bond them together. So we do just that, separating each atom with the nuclei operator ~.
But that didn't really do what we wanted now, did it? Sure, we have 2 nuclei in the same atom, but they aren't exactly bonded. They also don't bond in the right places. We want the 2 single proton hook stacks to come together. We could accomplish that by changing one of the nuclei declarations to swap the single and double hook stacks around. Wouldn't it be a lot better if we could just flip one of those nuclei over?
We use the flip operator ! before the nuclei that we want to rotate by 180°. This allows us to keep the same nuclei definition used in any situation, and just flip it over when we want to.
However, we still don't really have the structure that we want. Now we have the correct hook stacks bonding, except that, well, they aren't bonding. To solve this, we could alter both of the nuclei and take a single proton hook stack from one and put it into the other as a double proton stack. That would work and look fine, but there is a better way.
What we can do, is take the single hook stacks from both nuclei, put them together into a double stack and make it a new nuclei that sits between the others.
What have we done? That ruined everything! The middle stack is not in the correct position to bond with the other nuclei, and we can't flip it. What can we do? Easy, we just use the rotate operator ^ before the atom that we want to rotate by 90°
Voila! We have a beautiful, multi-nuclei atom. The good thing about splitting this into 3 nuclei, is that we can easily manipulate the bonding nucleus. Say we wanted to put neutrons on either side of that nucleus, then we just add them logically:
If we want to be more precise than that, which we might for purposes of calculating data from these expressions, then we could add those neutrons to the axial level like this:
That puts them into blocking positions, which may change the way the atom is rendered, for example.
You can use multiplication groups to expand a given section, but you must be careful what you are multiplying. You can only use the multiplication mechanism within a particle chain or a nuclear chain. The multiplication group can not start in one and end in the other. It must be completely contained within either type of chain. However, the multiplication group may start in a nuclear chain and contain a complete particle chain, as long as it ends in the nuclear chain.
A multiplication group starts with a ( and ends with a ) followed by a positive integer.
Multiplication occurs at the token level. You are multiplying the exact characters that are inside of the group. Therefore, you must make sure that it contains the necessary linking operators : or -.
Let's take a standard proton stack containing 2 neutrons between 2 protons.
If we wanted to use 3 of these to create a 6 proton stack, we could use a multiplication group like this:
If we wanted to add electrons to both poles, we just add them outside of the multiplication group:
We can do the same things with a nuclear chain.
Notice that we have to put a - inside of the multiplication group so that everything makes sense once it is expanded. You may have to do the same with the particle chains and the : operator, but they seem to be more resilient. The nuclear chains are not and require those linking tokens. Strictly speaking the link token after the multiplication group is not required, bit it doesn't hurt if used and makes it more readable.
We can actually nest a particle multiplication inside of a nuclear chain multiplication group.