Miles Periodic Table with Standard Periodic Table reference

Yeah, with Neo4j they don't have a lot of really straight forward tutorials.  

I've been trudging through a few github sites which are decent. Stackoverflow as well is okay for Neo4j questions. Loading new data is painful until you find the right line of code. Maybe try getting it going with AuraDB first.

This link might help:  https://mega.nz/file/Sl9EGDiT#FIIBda7Jm-rawL1ZFnSa3rbYA0nr699qlhBQk3gilEM

.

Completed two more tutorials, “Importing CSV data into Neo4j” and “Intermediate Cypher Queries”.

Cr6 wrote. With Neo4j they don't have a lot of really straight forward tutorials. 

I've been trudging through a few github sites which are decent. Stackoverflow as well. Loading new data is painful until you find the right line of code. Maybe try getting going with Auradb fist.

Here’s a list of all the Neo4j tutorials I currently see being offered at https://graphacademy.neo4j.com/. The six bold titles (one is repeated) are the five I’ve completed so far.

Fundamentals:
Neo4j Fundamentals
Cypher Fundamentals
Graph Data Modeling Fundamentals
Importing CSV data into Neo4j

Data Scientist:
Introduction to Neo4j Graph Science
Neo4j Graph Data Science Fundamentals
Path Finding with GDS
Community Detection with GDS
Coming soon – 3 more

Developer:
Building Neo4j Applications with .NET
Building Neo4j Applications with Go
Building Neo4j Applications with Java
Building Neo4j Applications with Python
Building Neo4j Applications with TypeScript
Introduction to Neo4j & GraphQL
Building Neo4j Applications with Node.js
Coming soon – 1 more

Cypher:
Importing CSV data into Neo4j
Intermediate Cypher Queries
Cypher Aggregations
Cypher Indexes and Constraints
Coming soon – 4 more

Neo4j and LLMs:
Neo4j & LLM Fundamentals
Build a Neo4j-backed Chatbot with TypeScript
Coming soon – 1 more

Neo4j Certifications:
Neo4j Certified Professional
Neo4j Graph Data Science Certification

They all seem straightforward to me. Each tutorial has included an indexed content list, videos, video transcriptions, sandbox cypher interface and Movie database. Much better then a regular old youtube tutorial. Each tutorial comes with an initial email ‘welcome’ as well as ‘congratulations’ upon completion. GraphAcademy appears to be making a real effort at being an excellent, free, learning resource. I'm thinking the Neo4j community can be a big help. My only complaint is that there are too many email messages.

I haven’t looked at AuraDB yet. I’m on my third or fourth sandbox. Each sandbox project lasts for three days but were renewed with new sandboxes automatically while I was taking the tutorials. Each expiration came with its own email message announcement including a ‘get Neo4jAura free’ offer.

To be honest, I find building queries for every problem presented to be difficult, but I gotta admit I’m slowly learning. A big saving grace, after a certain amount of due diligence, failed efforts and frustration the tutorial will provide the required solution. Given your plans and the opportunity, I may as well take a few more neo4j tutorials. Please feel free to point out the ones I should be aiming at.

Just noticed your mega.nz file, I'll take a look at it shortly.

Wow, a 238 page O'Reilly pdf, Graph Databases. Lovely surprise Octopus. I did notice that offering at Neo4j but had not yet checked it out. Thanks.
.

Thanks LTAM. The file was available for download from the Neo4j website.

.

Some notable progress. Rather than starting any additional Graph Academy tutorials, I went back to Neo4j Desktop, and followed instructions from the Desktop manual,
https://neo4j.com/docs/desktop-manual/current/operations/. I can now view and query: 1. the installed Movies graph database, as well as 2. another much larger, movie database created from an imported sample project Dump file from https://github.com/neo4j-graph-examples/recommendations. The image shows a portion of the second database.

I also read the first quarter of Ian Robinson, Jim Webber & Emil Eifrem’s Graph Databases pdf, again thank you very much. A few concepts elude me, like ‘normalization’, and ‘renormalization’, nevertheless I can certainly appreciate that a graph database with its ‘nodes’ and ‘relationships’ is easier to understand and query (via cypher) than previous databases and query languages like with SQL Server, which requires table joins, primary and foreign keys, etc.

Getting to this point with Neo4j Desktop was much simpler and easier than I’d first thought.

I take it there’s no further need for Neo4jAura.

What next?
.

Thanks LTAM that you are looking at this. My apologies for sending out 50 different platforms-directions to get started with graph databases.  I think if we can model something in Neo4j desktop we can move to the cloud - AuraDB which can allow more scaling power. Frankly, I think Miles' work can be best represented in graph databases.

What I'd like to do-see is creating a graph db with your X-Y-Z coordinates tables along with the Miles style Periodic table with proper "relationships" between what in old-database world is known as keys, but with "Relationships" between "Nodes". The thing is Graph DBs are lot more flexible with granularities so that we can say X relates to Y on "this"...X can be node, Y can be node, Z can be node and they relate with this...showing all the combinations. We can create a table with 1-360,000,000 to degrees and it is pretty fast to look up and assign. Data assignments are kind of spongy with graphs though. Basically I'm just looking to hook up our prior work to a graph style database just to show all the possible "bonds-relationships" between Atoms following Miles' rules. I think this can be done, it is just trudging through the work of it all. We can use allowed bond theories via Miles to layout the relationships. As atoms grow in protons-electrons-slot arrangements we can get a better "allowance" for what "bonds".  At the end of the day, I want to see all Atoms in the universe bonding via Miles...even stuff they say that should not exist....but per Miles' rules it "can".  This may seem like a ramble but we have achieved a few things and this like this is the next level. I think with the right data structures in a solid Graph DB (Neo4j) it can be done. Graph DB queries allow a lot of self-loops that are hard to do in Notebooks or SQL databases.  At the end of the day it is setting up how X slot relates to Y slot at this speed, direction and angle. I think a graphDb can kind of get us there if set up properly.

The cool thing about Graph databases and Neo4J is they allow iterative queries to show "Show me everything that connects with A and can connect with B and can connect via relationships until Z is reached" we are kind of looking at something similar with slot-bonding arrangements. But as the slots set, or bend, or grow more for what is allowed for the slot arrangements overall. I kind of had an "alpha" version of this with OrientDB but it wasn't always true in terms of Miles "true" -- some hacks existed. Basically each column in the Miles Periodic table would need to be a "node" with "relationships" to each other column in the base table. I have a few base queries that can show "relationships" and maybe create this in dynamic sql via the Mathis SQL database. We can try and do it old school as well with these "relationships" look this way with traditional e-p-n values (2p/3p/etc.). There may be something out there in a Graph DB already showing traditional bond paths that could be leveraged.  Just thoughts at the moment.

.
Cr6 wrote. At the end of the day, I want to see all Atoms in the universe bonding via Miles. … a graphDb can kind of get us there if set up properly.
Airman. Agreed. After a long learning curve of “50 different platforms and directions” (however many, its been a learning experience for which I’m grateful), and a few days of graph database videos and reading *, the Neo4j experts appear to indicate that most data domain problems can best be solved without a graph database. Whether a graph database would be a proper solution or not ultimately depends on the graphy-ness of the data. Graph databases can generally handle the most complex interrelated data. If the connections between nodes are as important as the nodes themselves, its a good indication that a graph solution is best. Between you and me, and your larger Machine Learning and AI goals, I think you’re right, a graph type charge field model is necessary, likely the best alternative available.

Cr6 wrote. I kind of had an "alpha" version of this with OrientDB but it wasn't always true in terms of Miles "true" -- some hacks existed. Basically each column in the Miles Periodic table would need to be a "node" with "relationships" to each other column in the base table.
Airman. Each column would need to be a node? Relationships between columns? I’ve seen that column mention elsewhere, I need to try and understand that better. In my mind each 1-19 atomic slot row stacks can be a node. Relationships would exist within and between stack rows. In any case, suffice to say all my python programming modeling efforts have involved plenty of hack oversimplifications. Be that as it may, as with the inclusion of 3d x, y and z coordinates, I’d do my best to ensure a graph is as physically descriptive and accurate as possible. For a charge field bonding graph database model I’m not convinced we should begin with the hacks currently built-into the atomic models and bonding widget.

How to go about designing a charge field graph model has been dominating my thoughts. They say to begin a graph modeling problem with a whiteboard – identifying the domain and best use cases with circles and arrows. Before tackling a bonding graph, we might start by graphing the charge field itself.

The universe consists of space, time, photons and photon collisions. All photons are nodes. A photon collision is the relationship. Space and time are embedded in the photon and photon collision properties.

Photon node properties.  Or Initial particle properties.
1. Mass, or radius.
2. Linear direction
3. Linear velocity. Photons travel through space at light speed.
4. Top Angular spin axis direction.
5. Angular spin velocity Photons spin with a surface velocity up to light speed.
6. Energy level spin count. List of sub-spin directions.
7. Position or location. At any given instant in time.

Photon relationship. The only relationship between photons are collisions.
(a:Photon)-[:COLLIDES_WITH]->( b:Photon)

All cypher relationships are defined as one-way, but that can’t be right. Photon a colliding with photon b is the same as saying b colliding with a, shouldn’t the collision be bi-directional?  A quick search led me to two references:
https://stackoverflow.com/questions/16876378/neo4j-one-directional-two-directional-relationships
https://graphaware.com/blog/neo4j/neo4j-bidirectional-relationships.html

The second reference concludes: Relationships in Neo4j can be traversed in both directions with the same speed. Moreover, direction can be completely ignored. Therefore, there is no need to create two different relationships between nodes, if one implies the other.

Ok, we can ignore a photon/photon collision’s a to b or b to a causal direction.

Collision relationship properties. A photon collision relationship has the following properties:
1. Time
2. Location in space.
3. Each photon’s collision center. I imagine the collision properties are sufficient to determine the collision’s outcome for each photon.

Photon node (final) properties. The collision has altered both photons’ properties, such as both photons’ linear directions. A strict adherence to the charge field principles would also allow that one or both photons’ outside spin might be striped or added, with accompanying mass/radii/energy level changes to the photons’ final properties.  

Electron node. A large enough photon, given additional enery boosting collisions, spin energy levels and radius becomes an electron – or an electron can lose it’s outermost spin and become a very large photon. The electron node has all the same particle property fields as the photon node.

With the electron have new node-node relationships:
Electron/photon collisions.
(a:Photon)-[:COLLIDES_WITH]->(e:Electron)
Electron/electron collisions.
(e:Electron)-[:COLLIDES_WITH]->(f:Electron)
Unlike bidirectional photon/photon collisions, I believe electron/photon collisions are usually directed as in a photon can collide with an electron – and bounce away again.
Miles has indicated that electron do not recycle charge as efficiently as protons do but these two relationships assume that electrons can recycle some charge.
Electron charge intake.
(a:Photon)-[:ENTERS]->(e:Electron)
Electron charge emision.
(e:Electron)-[:EMITS]->(c:Photon)

Neutron node. Eventually, given enough energy boosts, very large electrons can become protons or neutrons.
Neutron/photon collisions.
(a:Photon)-[:COLLIDES_WITH]->(n:Neutron)
Neutron/electron collisions.
(n:Neutron)-[:COLLIDES_WITH]->(e:Electron)
Neutron/neutron collisions.
(n:Neutron)-[:COLLIDES_WITH]->(m:Neutron)
Neutron charge intake.
(a:Photon)-[:ENTERS]->(n:Neutron)
Neutron charge emision.
(n:Neutron)-[:EMITS]->(c:Photon)

Proton node.
Proton/photon collisions.
(a:Photon)-[:COLLIDES_WITH]->(p:Proton)
Proton/electron collisions.
(p:Proton)-[:COLLIDES_WITH]->(e:Electron)
Proton/Proton collisions.
(p:Proton)-[:COLLIDES_WITH]->(q:Proton)
Proton charge intake.
(a:Photon)-[:ENTERS]->(p:Proton)
Proton charge emision.
(p:Proton)-[:EMITS]->(c:Photon)

Proton/Neutron collisions.
(p:Proton)-[:COLLIDES_WITH]->(n:Neutron)

Only photons can enter or be emitted from a larger type particle – charge recycling.

[:ORBITS]. For our bonding domain we could extend the above to include particle groups. The electron/proton and electron/neutron/proton sets might be sspecified by an orbit relationship.
(e:Electron)-[:ORBITS]->(p:Proton)
(n:Neutron)-[:ORBITS]->(p:Proton)
Orbits properties might include[Top, Bottom, Left, Right]

[:Bonds]. Next there might be a proton to proton bond relationship.
(two:Stack(p:Proton]-[:BONDS_TO]->(q:Proton)
Bond properties might include[Bottom, top, Left, Right]

Stack node. Stacks might be a new node with some particle properties
(two:Stack)  = (p:Proton]-[:BONDS_TO]->(q:Proton)

Then a six stack might be
(six:Stack) = (p:Proton)-[:BONDS_TO]→(q:Proton),
(q:Proton)-[:BONDS_TO]→(r:Proton),
(r:Proton)-[:BONDS_TO]→(s:Proton),
(s:Proton)-[:BONDS_TO]→(t:Proton),
(t:Proton)-[:BONDS_TO]→(u:Proton)

Where proton bonds exceed six, or when the proton/proton bonds are not parallel or anti-parallel, that bond might be indicated by an O_BOND relationship.
(three:Stack) - [:O_BONDS_TO]→(four:Stack)

All particle node labels: [Photon, Electron, Neutron, Proton, Stack].
All particle node properties: [1. Radius, 2. Linear direction, 3. Linear velocity, 4. Top spin angular spin direction, 5. Top spin angular spin velocity, 6. Energy level spin count, 7. Position]
All the relationship property types: [[:COLLIDES_WITH], [:ENTERS], [:EMITS], [:ORBITS], [:BONDS_TO], [:O_BONDS_TO]].

Again, I’ve yet to understand your far more advanced and developed thoughts on the subject. The above is just a fun first stab at it.

* A few of the graph modeling videos I’ve watched in the last few days:
1. Working With a Real-World Dataset in Neo4j. Import and Modeling
https://www.youtube.com/watch?v=oXziS-PPIUA
2. Secret Sauce of Neo4j: Modeling and Querying Graphs
https://www.youtube.com/watch?v=oRtVdXvtD3o  
3. A Skeptics Guide to Graph Databases - David Bechberger
https://www.youtube.com/watch?v=yOYodfN84N4
4. Graph Data Modeling Tips & Tricks
https://www.youtube.com/watch?v=eAbPgyouAE4  
.

Great comment LTAM. The great thing about graph databases is that they are fairly easy to expand with new nodes-relationships.

The stack node is what I was looking as well. For a "first run" ...really really cool insights. I like it that you took it to actual base entities "photons" and built up. Found this is worth a look on rotation:

https://www.boristhebrave.com/2022/07/31/rotation-graphs/
https://www.boristhebrave.com/2021/08/30/arc-consistency-explained/
https://www.boristhebrave.com/tag/graphs/
https://roguetemple.com/z/hyper/rogueviz.php

Also, with the SQL Server Database, we can create Nodes-Relationships via dynamic T-SQL.

Was looking at this today. Orientability is a bit of challenge with rotation "controls"...if we need to go this deep in a graph database...ouch. I think Miles tried to get away from some of this with his papers.:

https://en.wikipedia.org/wiki/Orientability#Examples

Papers on this.  Miles I think wanted to simplify his model and not use this.
https://www.math.uni-potsdam.de/fileadmin/user_upload/Prof-Geometrie/Dokumente/Lehre/Veranstaltungen/SS11/spingeo.pdf
https://api.pageplace.de/preview/DT0400.9781400883912_A26852321/preview-9781400883912_A26852321.pdf

For the Nodes and Relationships we may be able to create them via Dynamic T-SQL and JSON functions in SQL Server from the Mathis DB. We'll need to likely build something similar for Miles' structures.

Movie-Actor-Roles example for Neo4j:
---------------

CREATE (TheMatrix:Movie {title:'The Matrix', released:1999, tagline:'Welcome to the Real World'})
     CREATE (Keanu:Person {name:'Keanu Reeves', born:1964})
     CREATE (Carrie:Person {name:'Carrie-Anne Moss', born:1967})
     CREATE (Laurence:Person {name:'Laurence Fishburne', born:1961})
     CREATE (Hugo:Person {name:'Hugo Weaving', born:1960})
     CREATE (LillyW:Person {name:'Lilly Wachowski', born:1967})
     CREATE (LanaW:Person {name:'Lana Wachowski', born:1965})
     CREATE (JoelS:Person {name:'Joel Silver', born:1952})
     CREATE
     (Keanu)-[:ACTED_IN {roles:['Neo']}]->(TheMatrix),
     (Carrie)-[:ACTED_IN {roles:['Trinity']}]->(TheMatrix),
     (Laurence)-[:ACTED_IN {roles:['Morpheus']}]->(TheMatrix),
     (Hugo)-[:ACTED_IN {roles:['Agent Smith']}]->(TheMatrix),
     (LillyW)-[:DIRECTED]->(TheMatrix),
     (LanaW)-[:DIRECTED]->(TheMatrix),
     (JoelS)-[:PRODUCED]->(TheMatrix)

     CREATE (Emil:Person {name:"Emil Eifrem", born:1978})
     CREATE (Emil)-[:ACTED_IN {roles:["Emil"]}]->(TheMatrix)

     CREATE (TheMatrixReloaded:Movie {title:'The Matrix Reloaded', released:2003, tagline:'Free your mind'})
     CREATE
     (Keanu)-[:ACTED_IN {roles:['Neo']}]->(TheMatrixReloaded),
     (Carrie)-[:ACTED_IN {roles:['Trinity']}]->(TheMatrixReloaded),
     (Laurence)-[:ACTED_IN {roles:['Morpheus']}]->(TheMatrixReloaded),
     (Hugo)-[:ACTED_IN {roles:['Agent Smith']}]->(TheMatrixReloaded),
     (LillyW)-[:DIRECTED]->(TheMatrixReloaded),
     (LanaW)-[:DIRECTED]->(TheMatrixReloaded),
     (JoelS)-[:PRODUCED]->(TheMatrixReloaded)

     CREATE (TheMatrixRevolutions:Movie {title:'The Matrix Revolutions', released:2003, tagline:'Everything that has a beginning has an end'})
     CREATE
     (Keanu)-[:ACTED_IN {roles:['Neo']}]->(TheMatrixRevolutions),
     (Carrie)-[:ACTED_IN {roles:['Trinity']}]->(TheMatrixRevolutions),
     (Laurence)-[:ACTED_IN {roles:['Morpheus']}]->(TheMatrixRevolutions),
     (Hugo)-[:ACTED_IN {roles:['Agent Smith']}]->(TheMatrixRevolutions),
     (LillyW)-[:DIRECTED]->(TheMatrixRevolutions),
     (LanaW)-[:DIRECTED]->(TheMatrixRevolutions),
     (JoelS)-[:PRODUCED]->(TheMatrixRevolutions)

     CREATE (TheDevilsAdvocate:Movie {title:"The Devil's Advocate", released:1997, tagline:'Evil has its winning ways'})
     CREATE (Charlize:Person {name:'Charlize Theron', born:1975})
     CREATE (Al:Person {name:'Al Pacino', born:1940})
     CREATE (Taylor:Person {name:'Taylor Hackford', born:1944})
     CREATE
     (Keanu)-[:ACTED_IN {roles:['Kevin Lomax']}]->(TheDevilsAdvocate),
     (Charlize)-[:ACTED_IN {roles:['Mary Ann Lomax']}]->(TheDevilsAdvocate),
     (Al)-[:ACTED_IN {roles:['John Milton']}]->(TheDevilsAdvocate),
     (Taylor)-[:DIRECTED]->(TheDevilsAdvocate)
...
     CREATE
     (JessicaThompson)-[:REVIEWED {summary:'An amazing journey', rating:95}]->(CloudAtlas),
     (JessicaThompson)-[:REVIEWED {summary:'Silly, but fun', rating:65}]->(TheReplacements),
     (JamesThompson)-[:REVIEWED {summary:'The coolest football movie ever', rating:100}]->(TheReplacements),
     (AngelaScope)-[:REVIEWED {summary:'Pretty funny at times', rating:62}]->(TheReplacements),
     (JessicaThompson)-[:REVIEWED {summary:'Dark, but compelling', rating:85}]->(Unforgiven),
     (JessicaThompson)-[:REVIEWED {summary:"Slapstick redeemed only by the Robin Williams and Gene Hackman's stellar performances", rating:45}]->(TheBirdcage),
     (JessicaThompson)-[:REVIEWED {summary:'A solid romp', rating:68}]->(TheDaVinciCode),
     (JamesThompson)-[:REVIEWED {summary:'Fun, but a little far fetched', rating:65}]->(TheDaVinciCode),
     (JessicaThompson)-[:REVIEWED {summary:'You had me at Jerry', rating:92}]->(JerryMaguire)

     WITH TomH as a
     MATCH (a)-[:ACTED_IN]->(m)<-[:DIRECTED]-(d) RETURN a,m,d LIMIT 10;

Here's Dynamic T-SQL. Note I have totals for Protons-Neutrons at this Node Level:

Code:

WITH Mathis
AS (
   SELECT e.*
      ,m.AlphaType
      ,m.SlotOrder
      ,pbm.MathisCarouselAlphaTypeFull
      ,pbm.AlphaTypeRemainder
      ,m.Protons AS ProtonsMM

   FROM [Physics].[dbo].[vwElementsPositions] e
   JOIN [Physics].[dbo].[vwMilesMathisPeriodicTable] m ON e.AtomicNumber = m.AtomicNumber
      AND e.SlotNumber = m.SlotNumber
   LEFT JOIN [Physics].[dbo].[vwProtonBalanceMathis] pbm ON m.AtomicNumber = pbm.AtomicNumber
   where e.Protons > 0
   )

SELECT Max(AtomicNumber) as AtomicNumber,
'CREATE ('+Element+':Element {TotalProtons:'+Cast(Sum(protons) as varchar(10))+',   TotalNeutrons:'+Cast(Sum(Neutrons) as varchar(10))+', AtomicNumber: '+Cast(AtomicNumber as varchar(10))+ ', AtomicSymbol:'''+AtomicSymbol+''', AtomicType:'''+AtomicType +'''})' as AtomNode
  FROM Mathis
  where AtomicNumber < 93
  Group by AtomicNumber, Element, AtomicSymbol, AtomicType
Order by 1



Output:
CREATE (hydrogen:Element {TotalProtons:1, TotalNeutrons:1, AtomicNumber: 1, AtomicSymbol:'H', AtomicType:'nonmetal'})
CREATE (helium:Element {TotalProtons:2, TotalNeutrons:2, AtomicNumber: 2, AtomicSymbol:'He', AtomicType:'noblegas'})
CREATE (lithium:Element {TotalProtons:3, TotalNeutrons:3, AtomicNumber: 3, AtomicSymbol:'Li', AtomicType:'alkalimetal'})
CREATE (beryllium:Element {TotalProtons:4, TotalNeutrons:5, AtomicNumber: 4, AtomicSymbol:'Be', AtomicType:'alkalineearth'})
CREATE (boron:Element {TotalProtons:5, TotalNeutrons:5, AtomicNumber: 5, AtomicSymbol:'B', AtomicType:'metalloid'})
CREATE (cabon:Element {TotalProtons:6, TotalNeutrons:6, AtomicNumber: 6, AtomicSymbol:'C', AtomicType:'nonmetal'})
CREATE (nitrogen:Element {TotalProtons:7, TotalNeutrons:7, AtomicNumber: 7, AtomicSymbol:'N', AtomicType:'nonmetal'})
CREATE (oxygen:Element {TotalProtons:8, TotalNeutrons:9, AtomicNumber: 8, AtomicSymbol:'O', AtomicType:'nonmetal'})
CREATE (fluorine:Element {TotalProtons:9, TotalNeutrons:9, AtomicNumber: 9, AtomicSymbol:'F', AtomicType:'halogen'})
CREATE (neon:Element {TotalProtons:10, TotalNeutrons:10, AtomicNumber: 10, AtomicSymbol:'Ne', AtomicType:'noblegas'})
CREATE (sodium:Element {TotalProtons:11, TotalNeutrons:11, AtomicNumber: 11, AtomicSymbol:'Na', AtomicType:'alkalimetal'})
CREATE (magnesium:Element {TotalProtons:12, TotalNeutrons:12, AtomicNumber: 12, AtomicSymbol:'Mg', AtomicType:'alkalineearth'})
CREATE (aluminium:Element {TotalProtons:13, TotalNeutrons:13, AtomicNumber: 13, AtomicSymbol:'Al', AtomicType:'basicmetal'})
CREATE (silicon:Element {TotalProtons:14, TotalNeutrons:14, AtomicNumber: 14, AtomicSymbol:'Si', AtomicType:'metalloid'})
CREATE (phosphorus:Element {TotalProtons:15, TotalNeutrons:15, AtomicNumber: 15, AtomicSymbol:'P', AtomicType:'nonmetal'})
CREATE (sulfur:Element {TotalProtons:16, TotalNeutrons:16, AtomicNumber: 16, AtomicSymbol:'S', AtomicType:'nonmetal'})
CREATE (chlorine:Element {TotalProtons:17, TotalNeutrons:17, AtomicNumber: 17, AtomicSymbol:'Cl', AtomicType:'halogen'})
CREATE (argon:Element {TotalProtons:18, TotalNeutrons:18, AtomicNumber: 18, AtomicSymbol:'Ar', AtomicType:'noblegas'})
CREATE (potassium:Element {TotalProtons:19, TotalNeutrons:19, AtomicNumber: 19, AtomicSymbol:'K', AtomicType:'alkalimetal'})
CREATE (calcium:Element {TotalProtons:20, TotalNeutrons:20, AtomicNumber: 20, AtomicSymbol:'Ca', AtomicType:'alkalineearth'})
CREATE (scandium:Element {TotalProtons:21, TotalNeutrons:21, AtomicNumber: 21, AtomicSymbol:'Sc', AtomicType:'transitionmetal'})
CREATE (titanium:Element {TotalProtons:22, TotalNeutrons:22, AtomicNumber: 22, AtomicSymbol:'Ti', AtomicType:'transitionmetal'})
CREATE (vanadium:Element {TotalProtons:23, TotalNeutrons:23, AtomicNumber: 23, AtomicSymbol:'V', AtomicType:'transitionmetal'})
CREATE (chromium:Element {TotalProtons:24, TotalNeutrons:24, AtomicNumber: 24, AtomicSymbol:'Cr', AtomicType:'transitionmetal'})
CREATE (manganese:Element {TotalProtons:25, TotalNeutrons:25, AtomicNumber: 25, AtomicSymbol:'Mn', AtomicType:'transitionmetal'})
CREATE (iron:Element {TotalProtons:26, TotalNeutrons:26, AtomicNumber: 26, AtomicSymbol:'Fe', AtomicType:'transitionmetal'})
CREATE (cobalt:Element {TotalProtons:27, TotalNeutrons:27, AtomicNumber: 27, AtomicSymbol:'Co', AtomicType:'transitionmetal'})
CREATE (nickel:Element {TotalProtons:28, TotalNeutrons:28, AtomicNumber: 28, AtomicSymbol:'Ni', AtomicType:'transitionmetal'})
CREATE (copper:Element {TotalProtons:29, TotalNeutrons:29, AtomicNumber: 29, AtomicSymbol:'Cu', AtomicType:'transitionmetal'})
CREATE (zinc:Element {TotalProtons:30, TotalNeutrons:26, AtomicNumber: 30, AtomicSymbol:'Zn', AtomicType:'transitionmetal'})
CREATE (gallium:Element {TotalProtons:31, TotalNeutrons:30, AtomicNumber: 31, AtomicSymbol:'Ga', AtomicType:'basicmetal'})
CREATE (germanium:Element {TotalProtons:32, TotalNeutrons:30, AtomicNumber: 32, AtomicSymbol:'Ge', AtomicType:'metalloid'})
CREATE (arsenic:Element {TotalProtons:33, TotalNeutrons:30, AtomicNumber: 33, AtomicSymbol:'As', AtomicType:'metalloid'})
CREATE (selenium:Element {TotalProtons:34, TotalNeutrons:30, AtomicNumber: 34, AtomicSymbol:'Se', AtomicType:'nonmetal'})
CREATE (bromine:Element {TotalProtons:35, TotalNeutrons:32, AtomicNumber: 35, AtomicSymbol:'Br', AtomicType:'halogen'})
CREATE (krypton:Element {TotalProtons:36, TotalNeutrons:36, AtomicNumber: 36, AtomicSymbol:'Kr', AtomicType:'noblegas'})
CREATE (rubidium:Element {TotalProtons:37, TotalNeutrons:36, AtomicNumber: 37, AtomicSymbol:'Rb', AtomicType:'alkalimetal'})
CREATE (strontium:Element {TotalProtons:38, TotalNeutrons:36, AtomicNumber: 38, AtomicSymbol:'Sr', AtomicType:'alkalineearth'})
CREATE (yttrium:Element {TotalProtons:39, TotalNeutrons:36, AtomicNumber: 39, AtomicSymbol:'Y', AtomicType:'transitionmetal'})
CREATE (zirconium:Element {TotalProtons:40, TotalNeutrons:36, AtomicNumber: 40, AtomicSymbol:'Zr', AtomicType:'transitionmetal'})
CREATE (niobium:Element {TotalProtons:41, TotalNeutrons:36, AtomicNumber: 41, AtomicSymbol:'Nb', AtomicType:'transitionmetal'})
CREATE (molybdenum:Element {TotalProtons:42, TotalNeutrons:36, AtomicNumber: 42, AtomicSymbol:'Mo', AtomicType:'transitionmetal'})
CREATE (technetium:Element {TotalProtons:43, TotalNeutrons:36, AtomicNumber: 43, AtomicSymbol:'Tc', AtomicType:'transitionmetal'})
CREATE (ruthenium:Element {TotalProtons:44, TotalNeutrons:36, AtomicNumber: 44, AtomicSymbol:'Ru', AtomicType:'transitionmetal'})
CREATE (rhodium:Element {TotalProtons:45, TotalNeutrons:36, AtomicNumber: 45, AtomicSymbol:'Rh', AtomicType:'transitionmetal'})
CREATE (palladium:Element {TotalProtons:46, TotalNeutrons:36, AtomicNumber: 46, AtomicSymbol:'Pd', AtomicType:'transitionmetal'})
CREATE (silver:Element {TotalProtons:47, TotalNeutrons:42, AtomicNumber: 47, AtomicSymbol:'Ag', AtomicType:'transitionmetal'})
CREATE (cadmium:Element {TotalProtons:48, TotalNeutrons:48, AtomicNumber: 48, AtomicSymbol:'Cd', AtomicType:'transitionmetal'})
CREATE (indium:Element {TotalProtons:49, TotalNeutrons:48, AtomicNumber: 49, AtomicSymbol:'In', AtomicType:'basicmetal'})
CREATE (tin:Element {TotalProtons:50, TotalNeutrons:48, AtomicNumber: 50, AtomicSymbol:'Sn', AtomicType:'basicmetal'})
CREATE (antimony:Element {TotalProtons:51, TotalNeutrons:48, AtomicNumber: 51, AtomicSymbol:'Sb', AtomicType:'metalloid'})
CREATE (tellurium:Element {TotalProtons:52, TotalNeutrons:52, AtomicNumber: 52, AtomicSymbol:'Te', AtomicType:'metalloid'})
CREATE (iodine:Element {TotalProtons:53, TotalNeutrons:50, AtomicNumber: 53, AtomicSymbol:'I', AtomicType:'halogen'})
CREATE (xenon:Element {TotalProtons:54, TotalNeutrons:55, AtomicNumber: 54, AtomicSymbol:'Xe', AtomicType:'noblegas'})
CREATE (caesium:Element {TotalProtons:55, TotalNeutrons:54, AtomicNumber: 55, AtomicSymbol:'Cs', AtomicType:'alkalimetal'})
CREATE (barium:Element {TotalProtons:56, TotalNeutrons:53, AtomicNumber: 56, AtomicSymbol:'Ba', AtomicType:'alkalineearth'})
CREATE (lanthanum:Element {TotalProtons:57, TotalNeutrons:55, AtomicNumber: 57, AtomicSymbol:'La', AtomicType:'lanthanide'})
CREATE (cerium:Element {TotalProtons:58, TotalNeutrons:55, AtomicNumber: 58, AtomicSymbol:'Ce', AtomicType:'lanthanide'})
CREATE (praseodymium:Element {TotalProtons:59, TotalNeutrons:55, AtomicNumber: 59, AtomicSymbol:'Pr', AtomicType:'lanthanide'})
CREATE (neodymium:Element {TotalProtons:60, TotalNeutrons:56, AtomicNumber: 60, AtomicSymbol:'Nd', AtomicType:'lanthanide'})
CREATE (promethium:Element {TotalProtons:61, TotalNeutrons:58, AtomicNumber: 61, AtomicSymbol:'Pm', AtomicType:'lanthanide'})
CREATE (samarium:Element {TotalProtons:62, TotalNeutrons:61, AtomicNumber: 62, AtomicSymbol:'Sm', AtomicType:'lanthanide'})
CREATE (europium:Element {TotalProtons:63, TotalNeutrons:62, AtomicNumber: 63, AtomicSymbol:'Eu', AtomicType:'lanthanide'})
CREATE (gadolinium:Element {TotalProtons:64, TotalNeutrons:64, AtomicNumber: 64, AtomicSymbol:'Gd', AtomicType:'lanthanide'})
CREATE (terbium:Element {TotalProtons:65, TotalNeutrons:63, AtomicNumber: 65, AtomicSymbol:'Tb', AtomicType:'lanthanide'})
CREATE (dysprosium:Element {TotalProtons:66, TotalNeutrons:66, AtomicNumber: 66, AtomicSymbol:'Dy', AtomicType:'lanthanide'})
CREATE (holmium:Element {TotalProtons:67, TotalNeutrons:68, AtomicNumber: 67, AtomicSymbol:'Ho', AtomicType:'lanthanide'})
CREATE (erbium:Element {TotalProtons:68, TotalNeutrons:67, AtomicNumber: 68, AtomicSymbol:'Er', AtomicType:'lanthanide'})
CREATE (thulium:Element {TotalProtons:69, TotalNeutrons:68, AtomicNumber: 69, AtomicSymbol:'Tm', AtomicType:'lanthanide'})
CREATE (ytterbium:Element {TotalProtons:70, TotalNeutrons:66, AtomicNumber: 70, AtomicSymbol:'Yb', AtomicType:'lanthanide'})
CREATE (lutetium:Element {TotalProtons:71, TotalNeutrons:69, AtomicNumber: 71, AtomicSymbol:'Lu', AtomicType:'lanthanide'})
CREATE (hafnium:Element {TotalProtons:72, TotalNeutrons:70, AtomicNumber: 72, AtomicSymbol:'Hf', AtomicType:'transitionmetal'})
CREATE (tantalum:Element {TotalProtons:73, TotalNeutrons:72, AtomicNumber: 73, AtomicSymbol:'Ta', AtomicType:'transitionmetal'})
CREATE (tungsten:Element {TotalProtons:74, TotalNeutrons:72, AtomicNumber: 74, AtomicSymbol:'W', AtomicType:'transitionmetal'})
CREATE (rhenium:Element {TotalProtons:75, TotalNeutrons:76, AtomicNumber: 75, AtomicSymbol:'Re', AtomicType:'transitionmetal'})
CREATE (osmium:Element {TotalProtons:76, TotalNeutrons:76, AtomicNumber: 76, AtomicSymbol:'Os', AtomicType:'transitionmetal'})
CREATE (iridium:Element {TotalProtons:77, TotalNeutrons:76, AtomicNumber: 77, AtomicSymbol:'Ir', AtomicType:'transitionmetal'})
CREATE (platinum:Element {TotalProtons:78, TotalNeutrons:80, AtomicNumber: 78, AtomicSymbol:'Pt', AtomicType:'transitionmetal'})
CREATE (gold:Element {TotalProtons:79, TotalNeutrons:79, AtomicNumber: 79, AtomicSymbol:'Au', AtomicType:'transitionmetal'})
CREATE (mercury:Element {TotalProtons:80, TotalNeutrons:78, AtomicNumber: 80, AtomicSymbol:'Hg', AtomicType:'transitionmetal'})
CREATE (thallium:Element {TotalProtons:81, TotalNeutrons:80, AtomicNumber: 81, AtomicSymbol:'Tl', AtomicType:'basicmetal'})
CREATE (lead:Element {TotalProtons:82, TotalNeutrons:80, AtomicNumber: 82, AtomicSymbol:'Pb', AtomicType:'basicmetal'})
CREATE (bismuth:Element {TotalProtons:83, TotalNeutrons:82, AtomicNumber: 83, AtomicSymbol:'Bi', AtomicType:'basicmetal'})
CREATE (polonium:Element {TotalProtons:84, TotalNeutrons:83, AtomicNumber: 84, AtomicSymbol:'Po', AtomicType:'metalloid'})
CREATE (astatine:Element {TotalProtons:85, TotalNeutrons:85, AtomicNumber: 85, AtomicSymbol:'At', AtomicType:'halogen'})
CREATE (radon:Element {TotalProtons:86, TotalNeutrons:84, AtomicNumber: 86, AtomicSymbol:'Rn', AtomicType:'noblegas'})
CREATE (francium:Element {TotalProtons:87, TotalNeutrons:85, AtomicNumber: 87, AtomicSymbol:'Fr', AtomicType:'alkalimetal'})
CREATE (radium:Element {TotalProtons:88, TotalNeutrons:84, AtomicNumber: 88, AtomicSymbol:'Ra', AtomicType:'alkalineearth'})
CREATE (actinium:Element {TotalProtons:89, TotalNeutrons:86, AtomicNumber: 89, AtomicSymbol:'Ac', AtomicType:'actinide'})
CREATE (thorium:Element {TotalProtons:90, TotalNeutrons:88, AtomicNumber: 90, AtomicSymbol:'Th', AtomicType:'actinide'})

Basic Slots Syntax ---Fixed missing ending quote on LTAMKey:

Code:

WITH Mathis
AS (
 SELECT e.*
 ,m.AlphaType
 ,m.SlotOrder
 ,pbm.MathisCarouselAlphaTypeFull
 ,pbm.AlphaTypeRemainder
 ,m.Protons AS ProtonsMM

 FROM [Physics].[dbo].[vwElementsPositions] e
 JOIN [Physics].[dbo].[vwMilesMathisPeriodicTable] m ON e.AtomicNumber = m.AtomicNumber
 AND e.SlotNumber = m.SlotNumber
 LEFT JOIN [Physics].[dbo].[vwProtonBalanceMathis] pbm ON m.AtomicNumber = pbm.AtomicNumber
-- where e.Protons > 0
 )
SELECT AtomicNumber, SlotNumber, 'CREATE :SlotNumber {Protons:'+Cast(protons as varchar(10))+', CanBind:'+Cast(CanBind as varchar(1))+', AlphaType:'+Cast(AlphaType as varchar(10))+', SlotOrientation:'''+SlotOrien+''', SlotSpin:'''+ SlotSpin +''', BindKey:'''+BindKey+''', LTAMKey:'''+LTAMKey+'''})' as Slots
FROM MATHIS
order by 1,2

Sample:
-------
CREATE (:SlotNumber {Protons:1, CanBind:1, AlphaType:1, SlotOrientation:'Z', SlotSpin:'R', BindKeys:'BR', LTAMKey:'B1Z1R'})
CREATE (:SlotNumber {Protons:0, CanBind:0, AlphaType:0, SlotOrientation:'Y', SlotSpin:'N', BindKeys:'NN', LTAMKey:'N2Y0N'})
CREATE (:SlotNumber {Protons:0, CanBind:0, AlphaType:0, SlotOrientation:'Y', SlotSpin:'N', BindKeys:'NN', LTAMKey:'N3Y0N'})
CREATE (:SlotNumber {Protons:0, CanBind:0, AlphaType:0, SlotOrientation:'Z', SlotSpin:'N', BindKeys:'NN', LTAMKey:'N4Z0N'})
CREATE (:SlotNumber {Protons:0, CanBind:0, AlphaType:0, SlotOrientation:'Z', SlotSpin:'N', BindKeys:'NN', LTAMKey:'N5Z0N'})
CREATE (:SlotNumber {Protons:0, CanBind:0, AlphaType:0, SlotOrientation:'Y', SlotSpin:'N', BindKeys:'NN', LTAMKey:'N6Y0N'})
CREATE (:SlotNumber {Protons:0, CanBind:0, AlphaType:0, SlotOrientation:'Y', SlotSpin:'N', BindKeys:'NN', LTAMKey:'N7Y0N'})
CREATE (:SlotNumber {Protons:0, CanBind:0, AlphaType:0, SlotOrientation:'X', SlotSpin:'N', BindKeys:'NN', LTAMKey:'N8X0N'})
CREATE (:SlotNumber {Protons:0, CanBind:0, AlphaType:0, SlotOrientation:'X', SlotSpin:'N', BindKeys:'NN', LTAMKey:'N9X0N'})
CREATE (:SlotNumber {Protons:0, CanBind:0, AlphaType:0, SlotOrientation:'Z', SlotSpin:'N', BindKeys:'NN', LTAMKey:'N10Z0N'})
CREATE (:SlotNumber {Protons:0, CanBind:0, AlphaType:0, SlotOrientation:'Z', SlotSpin:'N', BindKeys:'NN', LTAMKey:'N11Z0N'})
CREATE (:SlotNumber {Protons:0, CanBind:0, AlphaType:0, SlotOrientation:'Z', SlotSpin:'N', BindKeys:'NN', LTAMKey:'N12Z0N'})
CREATE (:SlotNumber {Protons:0, CanBind:0, AlphaType:0, SlotOrientation:'Z', SlotSpin:'N', BindKeys:'NN', LTAMKey:'N13Z0N'})
CREATE (:SlotNumber {Protons:0, CanBind:0, AlphaType:0, SlotOrientation:'Y', SlotSpin:'N', BindKeys:'NN', LTAMKey:'N14Y0N'})
CREATE (:SlotNumber {Protons:0, CanBind:0, AlphaType:0, SlotOrientation:'Y', SlotSpin:'N', BindKeys:'NN', LTAMKey:'N15Y0N'})
CREATE (:SlotNumber {Protons:0, CanBind:0, AlphaType:0, SlotOrientation:'Z', SlotSpin:'N', BindKeys:'NN', LTAMKey:'N16Z0N'})
CREATE (:SlotNumber {Protons:0, CanBind:0, AlphaType:0, SlotOrientation:'Z', SlotSpin:'N', BindKeys:'NN', LTAMKey:'N17Z0N'})
CREATE (:SlotNumber {Protons:0, CanBind:0, AlphaType:0, SlotOrientation:'Z', SlotSpin:'N', BindKeys:'NN', LTAMKey:'N18Z0N'})
CREATE (:SlotNumber {Protons:0, CanBind:0, AlphaType:0, SlotOrientation:'Y', SlotSpin:'N', BindKeys:'NN', LTAMKey:'N19Y0N'})
CREATE (:SlotNumber {Protons:2, CanBind:1, AlphaType:2, SlotOrientation:'Z', SlotSpin:'A', BindKeys:'AA', LTAMKey:'A1Z2A'})

.

On Sat Mar 09, 2024 at 3:58 pm Cr6 wrote. The stack node is what I was looking as well. For a "first run" ...really really cool insights. I like it that you took it to actual base entities "photons" and built up.

Thanks Cr6, glad you liked my draft charge field model. I’ve added a hole and more particle groups to the draft list of charge field nodes: [Photon, Electron, Neutron, Proton, Elepro, Eleproneu, Hole, Bond, Obond, Stack, Atom, Molecule].
I may be childlike with my 3d demands, but I can justify that. I realize, of course, that a ‘graph’ is an abstract representation of data space, not reality.

Cr6 wrote: Found this is worth a look on rotation:

https://www.boristhebrave.com/2022/07/31/rotation-graphs/
https://www.boristhebrave.com/2021/08/30/arc-consistency-explained/
https://www.boristhebrave.com/tag/graphs/
https://roguetemple.com/z/hyper/rogueviz.php

Airman. Those are great links. You recently implied or intimated that there are existing graph databases out there that may present some alternative data structures worth considering. Well, I think boristhebrave’s rotation graphs are definitely worthy of discussion.

Here’s his image of a cube’s rotation graph for reference.

Quote. A rotation graph is an undirected graph where each outgoing edge is labeled with the integers 0 to d-1, where d is the number of outgoing edges (the degree of the vertex). The labels from a given node are each unique. A rotation map is the function that given a node and an edge label, returns the neighbor node that edge leads to, and the edge label that would lead back to the first node. … .

It turns out these additional labels are all you need to add a sense of direction to graphs.

Imagine I am standing on node A, and “facing” towards edge label 1. If the edges are labelled clockwise, then I can “turn” right by increasing the edge label by 1. And I can turn left by decreasing it. In either case, I need to wrap around from 0 to d-1 and visa versa. And you can perform a combined “step forward then about-face” by following the rotation map to a new node, and a new edge label.

So we have a rudimentary sort of tank controls for navigating the graph. All without introducing any notion of position. It’s like each edge warps you from the exit of one node to the entrace of another, basically like a bunch of levels with connectors between them.

It turns out you can actually accomplish a lot with these sort of tank controls. Let’s look at some examples.

Airman. If I understand correctly, rotation graphs are needed for many practical problems like creating meshes; a common application of which most are not aware. Adding rotation graphs to the bonding graph’s possible particle group nodes [Elepro, Eleproneu, Hole, Bond, Obond, Stack, Atom] may be extremely beneficial to the bonding graph, allowing the larger group nodes to maintain their internal spatial relationships between the group' internal individual particle nodes: [Electron, Neutron, Proton]. It seems to me that rotation graphs can handle the ‘orientation problem’ you mention in a subsequent post. A problem you think Miles must have tried to avoid. Just follow borissthebrave’s Arc Consistency guidelines https://www.boristhebrave.com/2021/08/30/arc-consistency-explained/
To be clear, I don’t come anywhere near understanding arc-consistency. I don’t expect any mobius strip type edges either.

Here’ a graph or two I ran across and thought I should share.

https://citeseerx.ist.psu.edu/doc_view/pid/52e38a7038f450854537a6c41539472652e53034

Explicit collision simulation of chemical reactions in a graph based artificial chemistry
A Toy Model of an artificial chemistry that treats molecules as graphs was implemented based on a simple Extended Hückel Theory method. Here we describe an extension of the model that models chemical…

https://citeseerx.ist.psu.edu/doc_view/pid/657fa3ef4494a62e15b57a682ff31bb90f42e71f

A graph-based toy model of chemistry
Large scale chemical reaction networks are a ubiquitous phenomenon, from the metabolism of living cells to processes in planetary atmospheres and chemical technology. At least some of these networks e...

https://chem.libretexts.org/Bookshelves/Physical_and_Theoretical_Chemistry_Textbook_Maps/Supplemental_Modules_(Physical_and_Theoretical_Chemistry)/Kinetics/06%3A_Modeling_Reaction_Kinetics/6.01%3A_Collision_Theory

6.1: Collision Theory
The collision theory explains that gas-phase chemical reactions occur when molecules collide with sufficient kinetic energy. The collision theory is based on the kinetic theory of gases; therefore only dealing with gas-phase chemical reactions are dealt with. Ideal gas assumptions are applied. Furthermore, we also are assuming:
1. All molecules are traveling through space in a straight line.
2. All molecules are rigid spheres.
3. The reactions concerned are between only two molecules.
4. The molecules need to collide.
Ultimately, the collision theory of gases gives the rate constant for bimolecular gas-phase reactions; it is equal to the rate of successful collisions. The rate of successful collisions is proportional to the fraction of successful collisions multiplied by the overall collision frequency.

Airman. Pardon me, they begin to blend together. Of course these extremely simple assumptions, describing molecules as rigid spheres, in a two body collision without spins can be a good start. We’d just have to add spin, as in boristhebrave’s rotation graphs to all the multi-particle group nodes(???).

Collision theory can “explain” the rates of various chemical reactions. They make the observation that after a thousand or so collisions as in a thousand different directions, its likely there’s only a single successful bond formed. Of a thousand successful bonds formed, maybe one of them involved a three-body collision. Four-body collisions are unheard of.

Cr6 wrote. Also, with the SQL Server Database, we can create Nodes-Relationships via dynamic T-SQL.

Airman. Ok, but for the record, I’m sure I’m not appreciating a dynamic T-SQL properly. Can a dynamic T-SQL graph implement motion?

That’s as far as I’ve gotten. You followed that up with three additional posts. I'll try to get to them. Please point out the most important stuff.
.

.

Added two images for clarity, that is, except for the extra “Guides” icon on the left, and the broken slider on the right.

On 12 Mar 2024 at 12:05 am Cr6 wrote.

Was looking at this today. Orientability is a bit of challenge with rotation "controls"...if we need to go this deep in a graph database...ouch. I think Miles tried to get away from some of this with his papers.:

https://en.wikipedia.org/wiki/Orientability#Examples

Papers on this.  Miles I think wanted to simplify his model and not use this.
https://www.math.uni-potsdam.de/fileadmin/user_upload/Prof-Geometrie/Dokumente/Lehre/Veranstaltungen/SS11/spingeo.pdf

https://api.pageplace.de/preview/DT0400.9781400883912_A26852321/preview-9781400883912_A26852321.pdf
Spin Geometry H. Blaine Lawson, jr. and Marie-Louise Michelsohn

Airman. I downloaded and briefly reviewed both the 1. 1989 Princeton University Press, and 2. Summer Term 2011 Potsdam University; Spin Geometry texts. They contain a lot of complex math I would hope we can avoid. Such as may be possible with using boristhebrave’s rotation graphs for our multiparticle nodes.

On 12 Mar 2024 at 12:05 am Cr6 wrote

For the Nodes and Relationships we may be able to create them via Dynamic T-SQL and JSON functions in SQL Server from the Mathis DB. We'll need to likely build something similar for Miles' structures.

Airman. Now it makes sense.

I opened up SQL Server and ‘Physics’ and executed your 12 Mar 2024 1:31 am Dynamic T-SQL query and obtained the same 90 line output. Each line is intended to be a cypher CREATE atom node with 5 properties.
15 CREATE (phosphorus:Element {TotalProtons:15,   TotalNeutrons:15, AtomicNumber: 15, AtomicSymbol:'P', AtomicType:'nonmetal'})

// CREATE (lead:Element {TotalProtons:82  // In notepad, lead in that position is bold - looks like a reserved sql function. The cypher query executed with no error.

Next I executed your 12 Mar 2024 at 2:08 dynamic T-SQL query and obtained a 1,710 row (90 elements x 19slots) output, the first 12 elements of which you included in the post, each atom’s slot properties.
// random single line.
2 5 CREATE 5:SlotNumber {Protons:0, CanBind:0, AlphaType:0, SlotOrientation:'Z', SlotSpin:'N', BindKey:'NN', LTAMKey:'N5Z0N})

Saved both outputs as notepad++ sql docs.

Need to convert those two query outputs into two sets of cypher create node commands. I take that means getting rid of the leading numbers: 1. AtomicNumber; and 2. AtomicNumber and SlotNumber - to the left of CREATE.

Copied the two outputs into excel docs, then striped the two outputs’ leading numeric columns. Copied both excel files back to notepad++ sql files.

I ran the first 90 cypher create commands and saw 90 nodes. The botom, earliest neo4j frame in the image above.

Next I tried running the 1710 create slot nodes and received the error:
Neo.ClientError.Statement.SyntaxError
Invalid input '1': expected "(", "ALL", "ANY" or "SHORTEST" (line 1, column 8 (offset: 7))
"CREATE 1:SlotNumber {Protons:1 CanBind:1       AlphaType:1     SlotOrientation:'Z' SlotSpin:'R'    BindKey:'BR'    LTAMKey:'B1Z1R})"
The error is shown the vertical , previous neo4j frame. The top neo4j frame is empty, awaiting a command.

Cr6, nevertheless, you are absolutely correct, the graph can be built using dynamic T-SQL and the ‘Physics’ sql database.

I am curious of what a graph of all the occupied slots of all 90 atoms would look like. Also can you invoke a stack without any protons? Hydrogen and Helium both occupy just one slots, quite a few of the smaller atoms have empty slots.

Looks like progress to me boss.
.

Thanks for the feedback LTAM....oops...forgot to add in the commas.

.

Well if its that easy I may as well try correcting it myself, … with no success.

Combining five images this time. Starting with a. at the top:
a. Closeup of SQL Server query SQL12Mar24.sql. The T-SQL file generated the cypher query that correctly created 90 element nodes. Three good locations are marked by green rectangles.
b. Closeup of SQL Server query SQL12Mar24two.sql. The cypher that generated yesterday’s neo4j error. That error, taken from yesterday, is repeated in d. In b. I tried identifying the two errors I thought I saw, located just above the two red rectangles: 1. a missing left paren “(“, and 2. a missing comma before “:SlotNum …” .
c. Closeup of SQL Server query SQL12Mar24three.sql. Contains the two corrections to b marked with green rectangles.
d. The neo4j error repeated from yesterday.
e. The latest neo4j error.

Now what’s wrong? I beg to defer to you.
.

Sorry don't want to ask people to try jumping in the lake without jumping in myself. Arrggh.

CREATE ( 1:SlotNumber {Protons:1, CanBind:1, AlphaType:1, SlotOrientation:'Z', SlotSpin:'R', BindKey:'BR', LTAMKey:'B1Z1R})


Maybe missing the opening "(". ?

.

90 Elements (red) with one or two character atomic symbol labels (too small to see here) and 210 unlabeled slot nodes (light blue). The default node limit for the display is 300. There are actually 1224 slot nodes.  

Hi Cr6, fancy meeting you here. A swim test sounds about right. The water's fine.

Initial sql CREATE statement:
'CREATE '+Cast(SlotNumber as varchar(10))+':SlotNumber {Protons:'+Cast(protons as varchar(10))+', CanBind:'+Cast(CanBind as varchar(1))+', AlphaType:'+Cast(AlphaType as varchar(10))+', SlotOrientation:'''+SlotOrien+''', SlotSpin:'''+ SlotSpin +''', BindKey:'''+BindKey+''', LTAMKey:'''+LTAMKey+'})' as Slots

Changed: +LTAMKey+'})' as Slots
To: +LTAMKey+'''})' as Slots

Changed: CREATE ('+Cast(SlotNumber as varchar(10))+',:SlotNumber
To: CREATE (:SlotNumber
The code was intended to show a slot number with labels 1-19. This change removes the label from the slot nodes. Don’t know why the numerical cast operation doesn’t work.  

Final sql CREATE statement:
'CREATE (:SlotNumber {Protons:'+Cast(protons as varchar(10))+', CanBind:'+Cast(CanBind as varchar(1))+', AlphaType:'+Cast(AlphaType as varchar(10))+', SlotOrientation:'''+SlotOrien+''', SlotSpin:'''+ SlotSpin +''', BindKey:'''+BindKey+''', LTAMKey:'''+LTAMKey+'''})' as Slots

Outside, before the CREATE statement, changed:
--where e.Protons > 0
To:
where e.Protons > 0
With double dashes, (commented out), 19 slots are generated for each atom, 19x90=1710.
Uncommented out (removed --), only occupied slots are generated for each atom, totaling 1224 slots.

--Initial CREATE slot nodes sql query
WITH Mathis
AS (
 SELECT e.*
 ,m.AlphaType
 ,m.SlotOrder
 ,pbm.MathisCarouselAlphaTypeFull
 ,pbm.AlphaTypeRemainder
 ,m.Protons AS ProtonsMM

 FROM [Physics].[dbo].[vwElementsPositions] e
 JOIN [Physics].[dbo].[vwMilesMathisPeriodicTable] m ON e.AtomicNumber = m.AtomicNumber
 AND e.SlotNumber = m.SlotNumber
 LEFT JOIN [Physics].[dbo].[vwProtonBalanceMathis] pbm ON m.AtomicNumber = pbm.AtomicNumber
-- where e.Protons > 0
 )
SELECT AtomicNumber, SlotNumber, 'CREATE '+Cast(SlotNumber as varchar(10))+':SlotNumber {Protons:'+Cast(protons as varchar(10))+', CanBind:'+Cast(CanBind as varchar(1))+', AlphaType:'+Cast(AlphaType as varchar(10))+', SlotOrientation:'''+SlotOrien+''', SlotSpin:'''+ SlotSpin +''', BindKey:'''+BindKey+''', LTAMKey:'''+LTAMKey+'})' as Slots
order by 1,2

--Final T-SQL Query
WITH Mathis
AS (
 SELECT e.*
 ,m.AlphaType
 ,m.SlotOrder
 ,pbm.MathisCarouselAlphaTypeFull
 ,pbm.AlphaTypeRemainder
 ,m.Protons AS ProtonsMM

 FROM [Physics].[dbo].[vwElementsPositions] e
 JOIN [Physics].[dbo].[vwMilesMathisPeriodicTable] m ON e.AtomicNumber = m.AtomicNumber
 AND e.SlotNumber = m.SlotNumber
 LEFT JOIN [Physics].[dbo].[vwProtonBalanceMathis] pbm ON m.AtomicNumber = pbm.AtomicNumber
where e.Protons > 0
 )
SELECT AtomicNumber, SlotNumber, 'CREATE (:SlotNumber {Protons:'+Cast(protons as varchar(10))+', CanBind:'+Cast(CanBind as varchar(1))+', AlphaType:'+Cast(AlphaType as varchar(10))+', SlotOrientation:'''+SlotOrien+''', SlotSpin:'''+ SlotSpin +''', BindKey:'''+BindKey+''', LTAMKey:'''+LTAMKey+'''})' as Slots
FROM MATHIS
order by 1,2

Used excel to remove the first two columns ( AtomicNumber and SlotNumber)

Still needs to be a slot label, then node to node relationships need defining.
.

Sorry to have you jump in with a quickly improvised flotation device!  Cool that you have it working with just :SlotNumber.

I have basic syntax and graph modelling errors.  Forgot to include the extra " '' " in the LTAMKey property in the dynamic sql:

LTAMKey:'''+LTAMKey+'''})'

May need to rebuild this with more denormalization on the Nodes to make each ID unique. I duped the slots section trying to combine it directly with the Atom so Create (1:SlotNumber {}) was duped for each atom while it needs to be unique. I could create a fake Row ID like "ROW_NUMBER() OVER (Select NULL ORDER BY 1 ) as ROWID" or some number artificially unique but later that can be hard to reference in for the Relationships.

Just being sloppy.

For the slots just made it super simple "Slot and Number":

SELECT distinct
SlotNumber,
'CREATE (Slot'+Cast(SlotNumber as varchar(10))+':SlotNumber {Slot:'+Cast(SlotNumber as varchar(10))+'})' as slots
FROM [Physics].[dbo].[vwMilesMathisPeriodicTable] m
order by 1,2
GO

CREATE (Slot1:SlotNumber {Slot:1})
CREATE (Slot2:SlotNumber {Slot:2})
CREATE (Slot3:SlotNumber {Slot:3})
CREATE (Slot4:SlotNumber {Slot:4})
CREATE (Slot5:SlotNumber {Slot:5})
CREATE (Slot6:SlotNumber {Slot:6})
CREATE (Slot7:SlotNumber {Slot:7})
CREATE (Slot8:SlotNumber {Slot:8})
CREATE (Slot9:SlotNumber {Slot:9})
CREATE (Slot10:SlotNumber {Slot:10})
CREATE (Slot11:SlotNumber {Slot:11})
CREATE (Slot12:SlotNumber {Slot:12})
CREATE (Slot13:SlotNumber {Slot:13})
CREATE (Slot14:SlotNumber {Slot:14})
CREATE (Slot15:SlotNumber {Slot:15})
CREATE (Slot16:SlotNumber {Slot:16})
CREATE (Slot17:SlotNumber {Slot:17})
CREATE (Slot18:SlotNumber {Slot:18})
CREATE (Slot19:SlotNumber {Slot:19})

This is your update in SQL. Just right click in SSMS and copy the "Slots" row output "without Headers" and it can be pasted directly into Neo4j. I may need to model this more in depth for Neo4j and just make a single SQL Script that outputs Nodes-Relationships in separate data result outputs so they can be copied and pasted.

This worked for me:

WITH Mathis
AS (
SELECT e.*
,m.AlphaType
,m.SlotOrder
,pbm.MathisCarouselAlphaTypeFull
,pbm.AlphaTypeRemainder
,m.Protons AS ProtonsMM

FROM [Physics].[dbo].[vwElementsPositions] e
JOIN [Physics].[dbo].[vwMilesMathisPeriodicTable] m ON e.AtomicNumber = m.AtomicNumber
AND e.SlotNumber = m.SlotNumber
LEFT JOIN [Physics].[dbo].[vwProtonBalanceMathis] pbm ON m.AtomicNumber = pbm.AtomicNumber
-- where e.Protons > 0
)
SELECT Distinct AtomicNumber,  'CREATE (:SlotNumber {Protons:'+Cast(protons as varchar(10))+', CanBind:'+Cast(CanBind as varchar(1))+', AlphaType:'+Cast(AlphaType as varchar(10))+', SlotOrientation:'''+SlotOrien+''', SlotSpin:'''+ SlotSpin +''', BindKeys:'''+BindKey+''', LTAMKey:'''+LTAMKey+'''})' as Slots
FROM MATHIS
order by 1,2

.

Happy Saint Patty’s Day!

I just now saw your latest posting Cr6. I'll study it, but decided to go ahead with the post I'd prepared below, showing you my final proper(?) SlotNumber node naming solution. In a rush, I have a party to go to.

I hope I didn’t embarrass you Cr6. I’d come, slowly, to the conclusion – intentionally or not, you wanted me to find the cypher code generating dynamic sql query errors. Need I mention I could never have come up with the query itself but I certainly enjoyed the opportunity to study it. I must have loaded, and deleted, the element and slot nodes in neo4j a half dozen times; practice makes perfect. I’ve been playing with SQL Server sql files, and using excel and notepad to be as organized as possible, which is an improvement over my usual scattered approach. Unfortunately, me posting feedback every day is tedious for everyone, fortunately the slot nodes are now being properly generated in neo4j and I don’t expect to be posting tomorrow.

The working final sql CREATE slot nodes code is:
'CREATE ('+'a'+CAST(AtomicNumber as varchar(10))+'s'+Cast(SlotNumber as varchar(10))+':SlotNumber {Protons:'+Cast(protons as varchar(10))+', CanBind:'+Cast(CanBind as varchar(1))+', AlphaType:'+Cast(AlphaType as varchar(10))+', SlotOrientation:'''+SlotOrien+''', SlotSpin:'''+ SlotSpin +''', BindKey:'''+BindKey+''', LTAMKey:'''+LTAMKey+'''})' as Slots

Yesterday I’d made a total of four changes to SQL12Mar24two.sql
1. Added the left paren “(“ after CREATE.
2. Added two back tic aportrophies “ ‘’ ” after +LTAMKey+,
3. Striped the slot labels, '+Cast(SlotNumber as varchar(10))+' from the left of :SlotNumber.
4. Outside CREATE, uncommented out “--where e.Protons > 0” to “where e.Protons > 0”

Restoring the slot node label was today’s goal. I found the neo4j node naming convention at https://neo4j.com/docs/cypher-manual/current/syntax/naming/
Where it states “Names should begin with an alphabetic character”. The numerical slot number alone, 1-19 is not allowed.

At first I added an “s” prefix to all the slots, as in
'CREATE ('+'s'+Cast(SlotNumber as varchar(10))+':SlotNumber
That resulted in another error - that name had already been assigned. Apparently every name must be unique, so I made each slot unique by including: ’a’+AtomNumber+’s’+SlotNumber … .
CREATE ('+'a'+CAST(AtomicNumber as varchar(10))+'s'+Cast(SlotNumber as varchar(10))+':SlotNumber … .
Which results, for example: CREATE (a61s4:SlotNumber ... .

The only problem now, in the image, a slot is selected, yet no where do I see the node’s unique slot number(?).

I guess the current goal is to create some relationships between the 1334 element and slot nodes.
.

Happy St. Patrick's day...having a small glass of Tullamore Dew.    I have this kind of working. It is really alpha. A lot of the modeling is try/rebuild until it gets closer to the goal and is validated as accurate. If we go to a lower granularity...we'll need to use AuraDB.  This already takes a while on my laptop and had to do the relationships in 20,000 row blocks or else it froze my screen. It adds in an internal UniqueID-Key for each Node-Relationship. It may be just a matter of syntax for the query to see the Element details on screen.  

I'm getting a lot of "HairBalls" with this granularity...it's like show everything binding with the top 25 Elements.
--------

Code:

USE [Physics]
GO

SET ANSI_NULLS ON
GO

/***
Use the CopyOutput Column to copy rows and paste them into Neo4j without the Header.
If you need to delete all prior work use this in the Neo4j query editor:

MATCH (n)
DETACH DELETE n

***/

--Build Element Nodes
WITH Mathis
AS (
 SELECT e.*
 ,m.AlphaType
 ,m.SlotOrder
 ,pbm.MathisCarouselAlphaTypeFull
 ,pbm.AlphaTypeRemainder
 ,m.Protons AS ProtonsMM

 FROM [Physics].[dbo].[vwElementsPositions] e
 JOIN [Physics].[dbo].[vwMilesMathisPeriodicTable] m ON e.AtomicNumber = m.AtomicNumber
 AND e.SlotNumber = m.SlotNumber
 LEFT JOIN [Physics].[dbo].[vwProtonBalanceMathis] pbm ON m.AtomicNumber = pbm.AtomicNumber
 where e.Protons > 0
 )

SELECT Max(AtomicNumber) as AtomicNumber,
'CREATE ('+Element+':Element {TotalProtons:'+Cast(Sum(protons) as varchar(10))+', TotalNeutrons:'+Cast(Sum(Neutrons) as varchar(10))+', AtomicNumber: '+Cast(AtomicNumber as varchar(10))+ ', AtomicSymbol:'''+AtomicSymbol+''', AtomicType:'''+AtomicType +'''})' as  CopyOutput
  FROM Mathis
  where AtomicNumber < 93
  Group by AtomicNumber, Element, AtomicSymbol, AtomicType
Order by 1
GO

--Build Slots
WITH Mathis
AS (
 SELECT e.*
 ,m.AlphaType
 ,m.SlotOrder
 ,pbm.MathisCarouselAlphaTypeFull
 ,pbm.AlphaTypeRemainder
 ,m.Protons AS ProtonsMM

 FROM [Physics].[dbo].[vwElementsPositions] e
 JOIN [Physics].[dbo].[vwMilesMathisPeriodicTable] m ON e.AtomicNumber = m.AtomicNumber
 AND e.SlotNumber = m.SlotNumber
 LEFT JOIN [Physics].[dbo].[vwProtonBalanceMathis] pbm ON m.AtomicNumber = pbm.AtomicNumber
-- where e.Protons > 0
 )
SELECT Distinct AtomicNumber,SlotNumber,  
'CREATE (:SlotNumber {AtomicNumber:'+Cast(AtomicNumber as varchar(10))+', SlotNumber:'+Cast(SlotNumber as varchar(10))+', Protons:'+Cast(protons as varchar(10))+', CanBind:'+Cast(CanBind as varchar(1))+', AlphaType:'+Cast(AlphaType as varchar(10))+', SlotOrientation:'''+SlotOrien+''', SlotSpin:'''+ SlotSpin +''', BindKeys:'''+BindKey+''', LTAMKey:'''+LTAMKey+'''})' as CopyOutput
FROM MATHIS
order by 1,2

--Build Atom to Atom Relationships with LTAM Keys from View's bonding logic -- note this still beta and may change
SELECT 0 as orderNum, 'CREATE ' as CopyOutput
UNION ALL
SELECT Distinct
1 as orderNum, '('+[ElementSrc]+')-[:BINDS_WITH {LTAMSrc:['''+LTAMKeySrc +'''], LTAMDest:['''+LTAMKeyDest +''']}]->('+[ElementDest]+'),' as CopyOutput
FROM [Physics].[dbo].[vwAtomicMilesMathisOrbitalsDetailAllBonds]
 where IsValid =1 and CanBindSrc = 1 and CanBindDest = 1
 ORDER BY 1,2

I'll add in your CREATE a+AtomNumber+s+SlotNumber:   since it is more straightforward. Found this to work. Quotes are more tricky than expected. Note always remove the last comma on the last row of the output for Relationships.:

Code:

--SLOTS by a1s1 style
WITH Mathis
AS (
   SELECT e.*
      ,m.AlphaType
      ,m.SlotOrder
      ,pbm.MathisCarouselAlphaTypeFull
      ,pbm.AlphaTypeRemainder
      ,m.Protons AS ProtonsMM

   FROM [Physics].[dbo].[vwElementsPositions] e
   JOIN [Physics].[dbo].[vwMilesMathisPeriodicTable] m ON e.AtomicNumber = m.AtomicNumber
      AND e.SlotNumber = m.SlotNumber
   LEFT JOIN [Physics].[dbo].[vwProtonBalanceMathis] pbm ON m.AtomicNumber = pbm.AtomicNumber
   where e.Protons > 0
   )

SELECT 0 as orderNum, 0 as AtomicNumber, 0 as SlotNumber, 'CREATE ' as CopyOutput
UNION ALL
SELECT Distinct 1 as orderNum, AtomicNumber, SlotNumber, '('+[Element]+')-[:HAS_SLOT]->(a'+Cast(AtomicNumber as varchar(10))+'s'+Cast(SlotNumber as varchar(10))+':SlotNumber),' as CopyOutput
FROM Mathis
order by 1 ,2,3

Here's the output may need to add in better labeling for the Relationships so they can be seen on screen. They have a limit on the Nodes at 300 by default both Elements and Slots apparently:
----------

.

Decided another day of feedback was needed.

1. 69,000 Row [:BINDS_WITH {...}] problem. I tried all the queries you’ve posted, starting with the USE [Physics] query you posted yesterday. I understand that that query has three sections, I only run one section at a time, uncommenting out the desired section and commenting out the other two.
The -- Build Element Nodes section runs fine.
The -- Build Slots section also runs fine.
However, the  --Build Atom to Atom Relationships section is a problem.
I get the SQL Server 69,001 row output, then strip the lead column in excel, carefully delete the final coma after (titanium) and try loading the cypher code into the neo4jBrowser. My machine slows way, way down. The final, two character,  hyphen and greater than, -> turns into a single right arrow in both excel and in neo4j. I tried converting the → into a -> without luck, all the remaining create lines (69000-1) also converted from ->into →. When I tried running that cypher query it would not finish; I ended up stopping the database after an hour. Bottom line, after four attempts, and three neo4j database restarts I could not get the 69,000 row [:BINDS_WITH {...}] relationships to load into neo4j, I think the problem involved the -> symbol.

2. SELECT distinct 19 slot numbers. I get the desired 19 row sql output, I don’t understand what this query does. Do I need to load it in addition to the Elements, SlotNumbers, and Build relationships?


3. MATCH p=()-[r:HAS_SLOT]->() RETURN p. After running your --SLOTS by a1s1 style query, and loading the 1,245 [:HAS_SLOT] relationships into neo4j and entering the same ‘MATCH p=()-[r:HAS_SLOT]->() RETURN p’ cypher query you used, I see the same image you last posted, limited to 300 nodes and moved about slightly to get a closer look.

When convenient, at some point soon, please consider indicating which queries are necessary and current.
.

Hi LTAM,

Yeah, I think our laptops are a little too lame to handle bigger data. Had to run the Relationships in 20,000 rows at a time. I'm still a little new to using the Cypher syntax myself. If I can get this really together we can export it to JSON and try to upload it to AuraDB. Sadly, errors from this are not that explanatory hence it takes a lot of time to track down syntax errors or modelling errors.

https://neo4j.com/cloud/platform/aura-graph-database/?ref=nav-get-started-cta

Used this in Neo4j to get over the pre-set 300 limit on Nodes-Relationships:

:config initialNodeDisplay: 4000

Helps to render everything. Still need to add in Labels for details on the Relationship Binding and Atom Nodes. Just a big hairball unless filtered a bit for 2 particular Atom Nodes.  This is using CanBindSrc=1 and CanBindDest=1.
https://medium.com/neo4j/graph-modeling-labels-71775ff7d121

https://neo4j.com/docs/browser-manual/current/operations/browser-settings/

.


Cr6, I ran ‘:config initialNodeDisplay: 4000’, changing the browser's default display node count from 300 to 4000 as you suggested, then reran cypher code ‘MATCH p=()-[r:HAS_SLOT]->() RETURN p’ which returned the above image. I see 90 elements and each element’s 1-19, ()-[HAS_SLOT]-->(SlotNumber). Hydrogen and Helium both appear as two nodes, along with a third element - associated with node 258 or 259. I don’t see any ‘element’ nodes. The gray nodes are unlabeled. What are they if not element nodes?

Breaking the 69,000  [BINDS_WITH] relationships into quarters before loading then into the neo4j database worked much better, each quarter took less than 5 minutes to load.

I read your recommended link, Graph Modeling: Labels by David Allen.
https://medium.com/neo4j/graph-modeling-labels-71775ff7d121  
It took me a lot longer than their estimated10 minutes.

David Allen wrote.

Data models exist to facilitate answering questions from the databases — they are not for creating pristine semantic models of domains.

I’m definitely guilty of trying to create pristine semantic models.

If you can’t figure which query will use the label you have in mind, don’t use it. You can always apply more labels later. (The YAGNI principle).

If I understand correctly, the question you wish to ask is, ‘Can element ‘a’ bond with element ‘b’, and if so, how?

Sorry I’m no help.


I can confirm your hairball sighting - a great view I just had to post.

Looking at the dynamic SQL query used to generate the element nodes:
CREATE (hydrogen:Element {TotalProtons:1, TotalNeutrons:1, AtomicNumber: 1, AtomicSymbol:'H', AtomicType:'nonmetal'})
I realize that the word ‘hydrogen’ in that statement is not a label or Element name, it is a unique temporary alias. In order to keep ‘hydrogen’ as a name it would need to be within the curly braces, like in:
CREATE (hyd:Element {Name:’hydrogen’, TotalProtons:1, TotalNeutrons:1, AtomicNumber: 1, AtomicSymbol:'H', AtomicType:'nonmetal'}), and where ‘hyd’ is just a temporary three-letter unique variable for that create statement, and it is not otherwise used. Am I right? Its the same for the create SlotNumber query, the ‘a’+AtomicNumber+‘s’+SlotNumber is just a temporary variable, and not used as a unique label or property in any way, that’s why I didn’t see it when I was looking at the SlotNumber properties.

P.S.
1. Changed to "-->(SlotNumber). Hydrogen and Helium both appear as"
2. Added second image
.

Yeah, the t-sql for the Create statements needs more tweaking. It was kind of posted just to explore. I'll try to get labels going. I need more syntax skill with cypher tbh. Still on the learning path. Aiming for what you posted earlier since Neo4j can do trillions of matches fairly quickly on low end hardware. Looks good what with what you are seeing.

Sample of what can be done with Neo4j:
https://m.youtube.com/watch?v=YVhLX1nGwRM

Hi LTAM,
Possibly need to change the CREATE statements to MERGE. Small tweaks at this point. I can't seem to get the "captions" to render as name:Element for the time being.  There's a LINK function that I may need to use to get these two datasets to render the Caption Labels - right now it defaults to the "Id" of the record instead of the "name".

Updated code:

Code:


--Build Element Nodes -- Remove LAST COMMA from the last record. CREATE only works with about 10,000 rows at a time.
WITH Mathis
AS (
   SELECT e.*
      ,m.AlphaType
      ,m.SlotOrder
      ,pbm.MathisCarouselAlphaTypeFull
      ,pbm.AlphaTypeRemainder
      ,m.Protons AS ProtonsMM

   FROM [Physics].[dbo].[vwElementsPositions] e
   JOIN [Physics].[dbo].[vwMilesMathisPeriodicTable] m ON e.AtomicNumber = m.AtomicNumber
      AND e.SlotNumber = m.SlotNumber
   LEFT JOIN [Physics].[dbo].[vwProtonBalanceMathis] pbm ON m.AtomicNumber = pbm.AtomicNumber
   where e.Protons > 0
   )

SELECT Max(AtomicNumber) as AtomicNumber,
'CREATE ('+Element+':baseelement {name:'''+Element+''', TotalProtons:'+Cast(Sum(protons) as varchar(10))+',   TotalNeutrons:'+Cast(Sum(Neutrons) as varchar(10))+', AtomicNumber: '+Cast(AtomicNumber as varchar(10))+ ', AtomicSymbol:'''+AtomicSymbol+''', AtomicType:'''+AtomicType +'''})' as  CopyOutput
  FROM Mathis
  where AtomicNumber < 91
  Group by AtomicNumber, Element, AtomicSymbol, AtomicType
Order by 1
GO

--Build Slots
WITH Mathis
AS (
   SELECT e.*
      ,m.AlphaType
      ,m.SlotOrder
      ,pbm.MathisCarouselAlphaTypeFull
      ,pbm.AlphaTypeRemainder
      ,m.Protons AS ProtonsMM

   FROM [Physics].[dbo].[vwElementsPositions] e
   JOIN [Physics].[dbo].[vwMilesMathisPeriodicTable] m ON e.AtomicNumber = m.AtomicNumber
      AND e.SlotNumber = m.SlotNumber
   LEFT JOIN [Physics].[dbo].[vwProtonBalanceMathis] pbm ON m.AtomicNumber = pbm.AtomicNumber
--   where e.Protons > 0
   )
SELECT Distinct AtomicNumber,SlotNumber,  
'CREATE (a'+Cast(AtomicNumber as varchar(10))+'s'+Cast(SlotNumber as varchar(10))+':SlotNumber {AtomicNumber:'+Cast(AtomicNumber as varchar(10))+', SlotNumber:'+Cast(SlotNumber as varchar(10))+', Protons:'+Cast(protons as varchar(10))+', CanBind:'+Cast(CanBind as varchar(1))+', AlphaType:'+Cast(AlphaType as varchar(10))+', SlotOrientation:'''+SlotOrien+''', SlotSpin:'''+ SlotSpin +''', BindKeys:'''+BindKey+''', LTAMKey:'''+LTAMKey+'''})' as CopyOutput
FROM MATHIS
order by 1,2

--Build Atom to Atom Relationships with LTAM Keys from View's bonding logic -- note this still beta and may change
SELECT 0 as orderNum, 'CREATE ' as CopyOutput
UNION ALL
SELECT Distinct
1 as orderNum, '('+[ElementSrc]+')-[:BINDS_WITH {AtomSrc:'''+ ElementSrc +''', AtomDest:'''+ ElementDest +''', LTAMSrc:'''+LTAMKeySrc +''', LTAMDest:'''+LTAMKeyDest +'''}]->('+[ElementDest]+')'+
 ',' as CopyOutput
FROM [Physics].[dbo].[vwAtomicMilesMathisOrbitalsDetailAllBonds]
 where IsValid =1 and CanBindSrc = 1 and CanBindDest = 1
 ORDER BY 1,2

.


Cr6 wrote. Possibly need to change the CREATE statements to MERGE.
Airman. This stuff is still plenty new to the both of us. I think you’re right.  

What was the cypher query you entered to obtain your last image?

As you’re no doubt aware, both CREATE and MERGE can be used to create nodes. CREATE creates a new node every time it is executed. MERGE will only create a new node if that node does not already exist.

What are the 326 nodes shown in the four hairballs above? There are 90 baseelements and 1710 SlotNumbers, a total of 1800 nodes. Neither baseelements nor SlotNumbers are shown.

Cr6 wrote.

...
--Build Element Nodes -- Remove LAST COMMA from the last record. CREATE only works with about 10,000 rows at a time.
...
'CREATE ('+Element+':baseelement {name:'''+Element+''', TotalProtons:'+Cast(Sum(protons) as varchar(10))+',   TotalNeutrons:'+Cast(Sum(Neutrons) as varchar(10))+', AtomicNumber: '+Cast(AtomicNumber as varchar(10))+ ', AtomicSymbol:'''+AtomicSymbol+''', AtomicType:'''+AtomicType +'''})'

First element example.
CREATE (hydrogen:baseelement {name:'hydrogen', TotalProtons:1,   TotalNeutrons:1, AtomicNumber: 1, AtomicSymbol:'H', AtomicType:'nonmetal'})

...
--Build Slots
'CREATE (a'+Cast(AtomicNumber as varchar(10))+'s'+Cast(SlotNumber as varchar(10))+':SlotNumber {AtomicNumber:'+Cast(AtomicNumber as varchar(10))+', SlotNumber:'+Cast(SlotNumber as varchar(10))+', Protons:'+Cast(protons as varchar(10))+', CanBind:'+Cast(CanBind as varchar(1))+', AlphaType:'+Cast(AlphaType as varchar(10))+', SlotOrientation:'''+SlotOrien+''', SlotSpin:'''+ SlotSpin +''', BindKeys:'''+BindKey+''', LTAMKey:'''+LTAMKey+'''})'

First slotNumber example.
CREATE (a1s1:SlotNumber {AtomicNumber:1, SlotNumber:1, Protons:1, CanBind:1, AlphaType:1, SlotOrientation:'Z', SlotSpin:'R', BindKeys:'BR', LTAMKey:'B1Z1R'})

...
--Build Atom to Atom Relationships with LTAM Keys from View's bonding logic -- note this still beta and may change
'('+[ElementSrc]+')-[:BINDS_WITH {AtomSrc:'''+ ElementSrc +''', AtomDest:'''+ ElementDest +''', LTAMSrc:'''+LTAMKeySrc +''', LTAMDest:'''+LTAMKeyDest +'''}]→('+[ElementDest]+')'

Final 69K [:BINDS_WITH] relationships row example.
CREATE … , (zirconium)-[:BINDS_WITH {AtomSrc:'zirconium', AtomDest:'zinc', LTAMSrc:'V3Y4V', LTAMDest:'T14Y1L'}]->(zinc)

Airman. Maybe the baseelement names need to be declared as baseelements.

MERGE (baseelement {name:'zirconium'})-[:BINDS_WITH{AtomSrc:'zirconium', AtomDest:'zinc', LTAMSrc:'V3Y4V', LTAMDest:'T14Y1L'}]->(baseelement {name:'zinc'}) ????

I missed that first 10,000 create warning till I was writing this report. I doubt it would have stopped me proceeding to break the 69K [:BINDS_WITH] rows into quarters for loading into neo4j. Each section seemed to take about 15-20 minutes, a little bit longer than the ms time counts:
1. (actinium)-[:BINDS_WITH {AtomSrc:'actinium', … 20K rows
Created 83 nodes, set 79992 properties, created 19998 relationships, completed after 897600 ms.
2. (germanium)-[:BINDS_WITH {AtomSrc:'germanium', … 20K rows
Created 82 nodes, set 79992 properties, created 19998 relationships, completed after 941935 ms.
3. (platinum)-[:BINDS_WITH {AtomSrc:'platinum', … 15K rows
Created 78 nodes, set 59992 properties, created 14998 relationships, completed after 678214 ms.
4. (tantalum)-[:BINDS_WITH {AtomSrc:'tantalum', … 15K rows.
Created 83 nodes, set 56024 properties, created 14006 relationships, completed after 855775 ms.


The first 1800 nodes are accounted for. I added the red numerical labels above for additional info; 1800 is actinium, 1801 is beryllium, 1802 is hydrogen, 1803 is aluminum, 1804 is antimony. A 326 collection of baseelements up to 2,126?
The 69K [:BINDS_WITH] relationships should only be creating relationship properties, not creating new nodes. In this case I’m wondering if we should try understanding the problem better before agreeing to change the 69K [:BINDS_WITH] rows to MERGE. Will new nodes still be created?
.

Hi LTAM,

With new node creation, most examples use MERGE. Yeah BINDS_WITH shouldn't create new nodes. There could be something obvious I'm missing. I should have had something a bit more together before posting it as an Alpha copy.

You may need to delete older nodes if they have changed since you may 3-4 versions of the nodes from current and prior runs?

.

After running two different MERGE statements with actinium [:BINDS_WITH] beryllium (69K rows 1 and 2), I ran a ‘MATCH (n) RETURN n’, then brought the three each actiniums and berylliums together by hand for the above image.

Cr6, my data base doesn't contain any old nodes. I rebuild it every time I use it, starting with ‘MATCH (n) DETACH DELETE n’, then adding the 90 element (now basseelement) nodes and 1710 SlotNumber nodes.

I was able to modify your t-sql query to generate the 69K row [:BINDS_WITH] relationship query from CREATE to MERGE in two different ways. A single CREATE to MERGE swap did not work. I needed to add the MERGE to each row. Neither MERGE form was able to complete a neo4j load with a quarter of the 69K rows, so I entered just a single [:BINDS_WITH] relationship for each, 69K rows 1 and 2 to see it the two methods would work.

1. Node 1800 – the bottom left node, is an unlabeled actinium ElementSrc and to its right is 1801, an unlabeled beryllium ElementDest. The [:BINDS_WITH] cypher relationship between those two nodes were ‘created’ by:
t-sql
'MERGE ('+[ElementSrc]+')-[:BINDS_WITH {AtomSrc:'''+ ElementSrc +''', AtomDest:'''+ ElementDest +''', LTAMSrc:'''+LTAMKeySrc +''', LTAMDest:'''+LTAMKeyDest +'''}]→('+[ElementDest]+')'

cypher
MERGE (actinium)-[:BINDS_WITH {AtomSrc:'actinium', AtomDest:'beryllium', LTAMSrc:'B10Z5R', LTAMDest:'V1Z4V'}]->(beryllium)

2. Node 1802 – the top left, actinium and 1803 – the top center beryllium, were ‘created’ by:
t-sql
'MERGE (:baseelement {name:'''+[ElementSrc]+'''})-[:BINDS_WITH {AtomSrc:'''+ ElementSrc +''', AtomDest:'''+ ElementDest +''', LTAMSrc:'''+LTAMKeySrc +''', LTAMDest:'''+LTAMKeyDest +'''}]->(:baseelement {name:'''+[ElementDest]+'''})'

cypher
MERGE (:baseelement {name:'actinium'})-[:BINDS_WITH {AtomSrc:'actinium', AtomDest:'beryllium', LTAMSrc:'B10Z5R', LTAMDest:'V1Z4V'}]->(:baseelement {name:'beryllium'})

Both MERGE statements added new nodes.

Only one of the three ‘actinium’ nodes or ‘beryllium’ nodes are the actual baseelement nodes with all the atomic properties. One node has just an ID 1800 or 1801; and the other node has an ID of 1802 or 1803 and a name: actinium or beryllium.  

Since I don’t believe a proper merge relationship should be adding new nodes I didn’t try loading smaller groups of say less than 10K of the 69K [:BINDS_WITH] rows at a time.

We're both missing something. Try this:
Graph Databases
by Ian Robinson, Jim Webber, and Emil Eifrem
Page 102

MERGE is like a mixture of MATCH and CREATE. If the pattern
described in the MERGE statement already exists in the graph, the
statement’s identifiers will be bound to this existing data, much as if
we’d specified MATCH. If the pattern does not currently exist in the
graph, MERGE will create it, much as if we’d used CREATE.

For MERGE to match existing data, all the elements in the pattern
must already exist in the graph. If it can’t match all parts of a pat‐
tern, MERGE will create a new instance of the entire pattern. This is
why we have used three MERGE statements in our LOAD CSV script.
Given a particular movie and a particular location, it’s quite possi‐
ble that one or another of them is already present in the graph. It’s
also possible for both of them to exist, but without a relationship
connecting them. If we were to use a single, large MERGE statement
instead of our three small statements:
MERGE (:Movie {title:title})-[:FILMED_IN]->
(:Location {name:location}))
the match would only succeed if the movie and location nodes and
the relationship between them already exist. If any one part of this
pattern does not exist, all parts will be created, leading to duplicate
data.

Our strategy is to break apart the larger pattern into smaller
chunks. We first ensure that the location is present. We next ensure
that the movie is present. Finally, we ensure that the two nodes are
connected. This incremental approach is quite normal when using
MERGE.

I'll keep looking.
.

.

According to our current data, Actinium has six potential bonding locations with Beryllium. Those actinium bonding slots include: 'B10Z5R', 'B13Z5L', 'B15Y5R', 'T11Z5R', 'T12Z5L', 'T14Y5L'; any of which may bond with beryllium slot 1 V1Z4V. This image is intended to show that duplicate baseelement nodes were not created when executing six merge cypher queries creating the six relationships.

Re-posting the final paragraph of the page 102 Graph Databases quote:

Our strategy is to break apart the larger pattern into smaller chunks. We first ensure that the location is present. We next ensure that the movie is present. Finally, we ensure that the two nodes are connected. This incremental approach is quite normal when using MERGE.

Having seen a few related cypher MERGE examples in the last couple of days, I understand how one may apply the above strategy. To create a [:BINDS_WITH] relationship between two elements: first match the elements, then merge the relationship. As in:
MATCH (actinium:baseelement {name: ‘actinium’})
MATCH (beryllium:baseelement {name: ‘beryllium’})
MERGE (actinium)-[:BINDS_WITH {AtomSrc:'actinium', AtomDest:'beryllium', LTAMSrc:'B10Z5R', LTAMDest:'V1Z4V'}]→(beryllium)

That is the first of 69K cypher queries. Two match statements must be added to the query before attempting to merge (create) each of the 69K [:BINDS_WITH] row relationships.

Change the portion of the t-sql cypher generating code from:
'MERGE ('''+[ElementSrc]+''')-[:BINDS_WITH {AtomSrc:'''+ ElementSrc +''', AtomDest:'''+ ElementDest +''', LTAMSrc:'''+LTAMKeySrc +''', LTAMDest:'''+LTAMKeyDest +'''}]->('+[ElementDest]+')'
To:
'MATCH ('''+[ElementSrc]+''':baseelement {name: '''+ ElementSrc +'''})
MATCH ('''+[ElementDest]+''':baseelement {name: '''+ ElementDest +'''})
MERGE ('+[ElementSrc]+''')-[:BINDS_WITH {AtomSrc:'''+ ElementSrc +''', AtomDest:'''+ ElementDest +''', LTAMSrc:'''+LTAMKeySrc +''', LTAMDest:'''+LTAMKeyDest +'''}]->('+[ElementDest]+')'

That’s just a suggestion. I haven't tried creating the modified t-sql 69K row relationships yet. Given the fact that 69K is a huge number of rows, I suspect that there may be some additional benefit by adding a constraint or index on the baseelement’s name property. I’m certain you’re way more cognizant of the problem than I am. I’d be happy to hear your feedback.
.

Ace work with Match and Merge LTAM. Another decent reference:

https://neo4j.com/docs/cypher-cheat-sheet/5/auradb-enterprise/

.
…
1 as orderNum, 'MATCH ('+ElementSrc+':baseelement {name: '''+ElementSrc+'''})
MATCH ('+ElementDest+':baseelement {name: '''+ElementDest+'''})
MERGE ('+ElementSrc+')-[:BINDS_WITH {AtomSrc:'''+ElementSrc+''', AtomDest:'''+ ElementDest +''', LTAMSrc:'''+LTAMKeySrc+''', LTAMDest:'''+LTAMKeyDest+'''}]->('+[ElementDest]+')'
as CopyOutput
…

Sorry Boss, I’m stuck.

I’ve modified the cypher generating t-sql code as shown above; adding the two match baseelement (ElementSrc and ElementDest) clauses before the merge, in order to create the [:BIND_WITH] relationship without duplicating any nodes.

Each match, match merge cypher query works fine, setting four properties and creating one [BIND_WITH] relationship as I did on 29 March. However, when two or more rows of match, match merge cypher queries are added together as in these two (of 69K) [BINDS_WITH] lines,

MATCH (aluminium:baseelement {name: 'aluminium'})  MATCH (antimony:baseelement {name: 'antimony'})  MERGE (aluminium)-[:BINDS_WITH {AtomSrc:'aluminium', AtomDest:'antimony', LTAMSrc:'E5Z2E', LTAMDest:'T14Y2L'}]->(antimony)
MATCH (aluminium:baseelement {name: 'aluminium'})  MATCH (antimony:baseelement {name: 'antimony'})  MERGE (aluminium)-[:BINDS_WITH {AtomSrc:'aluminium', AtomDest:'antimony', LTAMSrc:'V1Z2V', LTAMDest:'B10Z2R'}]→(antimony)

The following error is returned:
Neo.ClientError.Statement.SyntaxError
WITH is required between MERGE and MATCH (line 2, column 1 (offset: 224))
"MATCH (aluminium:baseelement {name: 'aluminium'})  MATCH (antimony:baseelement {name: 'antimony'})  MERGE (aluminium)-[:BINDS_WITH {AtomSrc:'aluminium', AtomDest:'antimony', LTAMSrc:'V1Z2V', LTAMDest:'B10Z2R'}]->(antimony)"

I’ve tried looking up and adding WITH without any success.

???
.

Sorry LTAM...I'm seeing the same thing. The errors are tricky to debug. I may need to imitate a known good working script.

https://github.com/neo4j-partners/hands-on-lab-neo4j-and-azure/tree/main/Lab%203%20-%20Moving%20Data

.

680 Relationships is an accumulated number.

Given the Neo. ClientError.Statement.SyntaxError recommendation,
“WITH is required between MERGE and MATCH … ”.
I tried looking harder at WITH.
https://neo4j.com/docs/cypher-manual/current/clauses/with/

WITH
The WITH clause allows query parts to be chained together, piping the results from one to be used as starting points or criteria in the next.

It is important to note that WITH affects variables in scope. Any variables not included in the WITH clause are not carried over to the rest of the query. The wildcard * can be used to include all variables that are currently in scope.

WITH can also be used to introduce new variables containing the results of expressions for use in the following query parts (see Introducing variables for expressions). For convenience, the wildcard * expands to all variables that are currently in scope and carries them over to the next query part (see Using the wildcard to carry over variables).

“WITH *” (I also tried “WITH true as pass”) has been added to the end of the t-sql cypher generating section.

1 as orderNum, 'MATCH ('+ElementSrc+':baseelement {name: '''+ElementSrc+'''})
MATCH ('+ElementDest+':baseelement {name: '''+ElementDest+'''})
MERGE ('+ElementSrc+')-[:BINDS_WITH {AtomSrc:'''+ ElementSrc +''', AtomDest:'''+ ElementDest +''', LTAMSrc:'''+LTAMKeySrc +''', LTAMDest:'''+LTAMKeyDest +'''}]->('+[ElementDest]+') WITH *'
as CopyOutput

Unfortunately, the largest number of “match, match, merge WITH *” chained sets I’ve been able to run as a single cypher query is 300. Running 300 set 1200 properties, created 300 relationships, completed after 24361 ms.
Running 500 returns a “WebSocket connection failure”.
Running 1,000 returns a “Neo.TransientError.General.StackOverFlowError”
I actually started at a 10K set and worked downward from there.

Trying to load all 69K [BINDS_WITH] relationships 300 at a time would require 230 separate cypher query entries.

As currently coded, “WITH *” or “WITH true as pass” are not acceptable solutions.
.

.

Slow progress. The image shows the first 1K (of 69K) [BINDS_WITH] relationships and the cypher query for the 1001st, not yet executed. “WITH *” at the end of the query has been replaced with a semicolon.

The section of the T-SQL query that generated the cypher query.
...
1 as orderNum, 'MATCH ('+ElementSrc+':baseelement {name: '''+ElementSrc+'''})
MATCH ('+ElementDest+':baseelement {name: '''+ElementDest+'''})
MERGE ('+ElementSrc+')-[:BINDS_WITH {AtomSrc:'''+ ElementSrc +''', AtomDest:'''+ ElementDest +''', LTAMSrc:'''+LTAMKeySrc +''', LTAMDest:'''+LTAMKeyDest +'''}]→('+[ElementDest]+');'
as CopyOutput
...

I usually copy the sql server output into excel, then delete the first column and first row. Next I copy a block of rows of the single column ‘data’ from excel to paste into the neo4j desktop browser’s query input. A single character right arrow in the first row often needs to be corrected with a double character right arrow ->. The most recent cypher query executed included a block of the 150 (850-1000) of [BINDS_WITH] relationships. Upon execution, the block of 150 match, match, merge statements are converted into a stack of 150 separate cypher queries, each runs sequentially, receiving a little green checkmark as it is completed, all 150 were completed in less than a minute.

Loading the 69k bonds using the semicolon alternative may take many hours, at least it seems doable.  As a last resort anyway, one would hope for a more expeditious loading process.


The bonding database schema is a single baseelement node with a single outgoing loop back to itself. The up to 19 slots for each basseelement are not loaded.

Cr6 wrote.

https://github.com/neo4j-partners/hands-on-lab-neo4j-and-azure/tree/main/Lab%203%20-%20Moving%20Data

Airman. A couple of posts ago I’d asked whether there might be some benefit by adding a constraint or index on the baseelement’s name property. In the image we can see the baseelement aluminum contains unique elementid and id properties, so why add another index(?). Your hands-on-lab-neo4j-and-azure Lab 3 - Moving Data link tutorial may have been intended as an affirmative. Thanks for that. I was able to complete the lab’s initial single day data entry from the SEC's EDGAR database. Nice to see that one may generate and execute basic cypher queries by clicking on database node labels on the left.

Unfortunately, I was unable to load all the Lab 3. More Performant year of financial data. Loading the companies with neo4j desktop 25 minutes; the azure cloud load time indicated a completion time of 15687 ms, 2.6 minutes. Loading the managers took about the same length of time as the companies. No joy loading the relationships, after 45 minutes receiving -

Neo.TransientError.General.MemoryPoolOutOfMemoryError
The allocation of an extra 2.0 MiB would use more than the limit 716.8 MiB. Currently using 715.0 MiB. dbms.memory.transaction.total.max threshold reached

Before trying again, I would need to investigate how to load an extra 2.0 MiB, which I somehow doubt would be sufficient.
.

.

Whoops, I broke it, or I’m lost, or both.

Last time, I wrote. The up to 19 slots for each basseelement are not loaded.

Airman. After having loaded 3K of the 69K bond relationships I thought I better go ahead and add the slots already.

Long story short, D’uh; there’s nothing connecting the slots to the elements. Back on March 17 and 18 or so the standalone T-SQL code, --SLOTS by a1s1 style ...‘MATCH p=()-[r:HAS_SLOT]->() RETURN p’ ...,  the output appeared as 90 elements, each with its set of [HAS_SLOT] relationship. At the time I didn't realize that those 90 gray nodes were not baseelements, instead, they were 90 nodes created as anchors for the 1244 slots.

So begin again as usual, by creating the 90 baseelement nodes.
‘CREATE (hydrogen:baseelement {name:'hydrogen', TotalProtons:1,   TotalNeutrons:1, AtomicNumber: 1, AtomicSymbol:'H', AtomicType:'nonmetal'})’
...

Then create each atom's set of occupied slots.
‘CREATE (a1s1:SlotNumber {AtomicNumber:1, SlotNumber:1, Protons:1, CanBind:1, AlphaType:1, SlotOrientation:'Z', SlotSpin:'R', BindKeys:'BR', LTAMKey:'B1Z1R'})’

Where the a is followed by 1-90 and s by 1-19. Each SlotNumber is unique.
Then, to ensure the 1244 slots are added to the baseelement nodes and not to default anchor nodes.

‘MATCH (:baseelement), MATCH (:SlotNumber), MERGE (:baseelement)-[HAS_SLOT]-> (:SlotNumber)’

All bonds can then occur between SlotNumber nodes rather than between the baseelement nodes themselves.  
Assign the 69K bonds.
 
‘MATCH (a:SlotNumber) MATCH (b:SlotNumber), MERGE (a:SlotNumber)-[CAN_BIND]→(b:SlotNumber)’

Note I haven’t worked out any such SlotNumber [CAN_BIND] queries yet. Just wondering whether I'm understanding correctly or taking this MATCH MATCH thing too far.

Cr6, please pardon my confusion. What say you? Any T-SQL cypher generated queries would be appreciated.
.

Hi LTAM, sorry for this dragging out. I had issues just getting a MATCH query to display output. Will work on getting a cypher query going. Note this really slow going for me as well. Actually real clear examples of cypher are not that easy to find.

You may want to try your scripts on AuraDb if the local is reaching limits.

Hey LTAM, I was able to import this into AuraDB (cloud base version of Neo4j).  Just did the "BINDS_WITH" and looked at the relationships. They allow a pretty easy upload of a .csv file. We may want to use AuraDB...takes some time to start up a freeware cluster (like databricks)...but it provides capacity flexibility. This is kind of where I'm going at this point. This took like seconds to import a .csv export of about 8 mbs from a SQL query "save as" in SQL Server Management Studio:



Query for .csv file:

Code:

SELECT Distinct ElementSrc, ElementDest, LTAMKeySrc, LTAMKeyDest, ProtonsSrc, ProtonsDest, AlphaTypeSrc, AlphaTypeDest, AtomicNumberSrc, AtomicNumberDest, SlotNumberSrc, SlotNumberDest, SlotOrienSrc, SlotOrienDest, SlotSpinSrc, SlotSpinDest
  FROM [Physics].[dbo].[vwAtomicMilesMathisOrbitalsDetailAllBonds]

Still need a routine to help bust out the "hairball". May need to use the WHERE clause to limit it to trackable and clean "links".

It is a little closer to seeing "show me everything in the universe per Miles' bonding that has match in the real world?"


Actually, more I look at this it is still kind of in an Alpha state looking at the Raw view. Labels are not matching with the Node?  
This might be just a late night "scratch" and redo. May need to create a general "Element" node and reference it without the ElementSrc-ElementDest set up. Seems to be overcooking the lookups.

I have a new import sort of working it is pretty basic with ElementSrc-ElementDest and Relationship property keys of LTAMKeySrc and LTAMKeyDest.  Had to delete everything and re-import/upload the .csv file with headers. Getting better.  I'm going to use the AuraDB just because it is easier to work with than Neo4j desktop. Your posts earlier on relationships will need to be done-data set by data set-- should be do-able.  It is like "Super-Hairball-ish" right now.  





This is everybody (src) and their brother (dest) with valid BINDS_WITH:

.

Proof of life from the Aura cloud.

Cr6 wrote. It is like "Super-Hairball-ish" right now   .  
Airman. Just source and destination elements for me so far, no other properties, close enough to see the label names. Wonder why there are only 87 elements? I see you have 87 source and 86 destination elements(?).  

Using T-SQL to generate a 291,152 row csv file was a surprise. So was dragging and dropping it into Aura. I’ll call it bonds.csv. Its about the same file size, 16,097 KB as the 69K row BINDS_WITH cypher query set, 16,152 KB.

Cr6 wrote. You may want to try your scripts on AuraDb if the local is reaching limits.
Airman. I’ve been reaching my limits alright, but I think I see what you mean. I assume bonds.csv is all the BINDS_WITH relationships. It is still necessary to create the 90 baseelement nodes and 1244 SlotNumber nodes using your T-SQL cypher generator. The bonds present in bonds.csv alleviate the need of having to load to 69K [BINDS_WITH] relationships.

Cr6 wrote. Your posts earlier on relationships will need to be done-data set by data set-- should be do-able.
Airman. Thanks for a path forward.
.

LTAM wrote:Cr6 wrote. It is like "Super-Hairball-ish" right now  afro .  
Airman. Just source and destination elements for me so far, no other properties, close enough to see the label names. Wonder why there are only 87 elements? I see you have 87 source and 86 destination elements(?).

Yeah, I'm not sure what is up with 86 destination. I did remove the Carbons with Hydro-Carbons that is C-H type bonds...it may be the reason. Will need to do some research into it. There may be a good link that is dropped out due to this pulled from "known" bonds from ChemSpider. Something that should exist may not be showing up.

The source view that aligns this may have reasons for drop outs as well. Tried to match Chemspider pulls with Miles' and your bonding (and some of mine). Could be something super-simple. Basically, it breaks out every "molecule" from Chemspider into separate elements and sets the bonding per slot type-protons per Miles (high slots to low slots). A few slots are removed due to non-binding ability in the T-SQL view.

Here's a snippet from the Stored Procedure that builds the base table...setting known non-valid bonds that should have dropped out -- CH style bonds are fully dropped out at the moment this table is the source for the View: dbo.AtomicMilesMathisOrbitalParsed -- this may need to be setup to allow multiple bonds per Element to Element -- it currently only shows 1 Element to 1 Element.  If you have the following it only shows bonds between Ba-F-Y not Ba-F5-Y...was just trying to get to "can this accurately bond with the base elements and not multiples?"...this question of "multiples" will need to be revisited and set up since Molecules use the topology of the structure (in-out/up-down/charge flows/protons/electrons/etc.). With Cypher queries it should be possible to show bonds with F5 below in the proper sequence...bonds not seen every day might need a second look as well:

ZMolecule                              ZItem ZFormula
Barium yttrium fluoride (1:1:5) Ba BaF5Y

This has 62 rows for possible bonds...which are really "bonding" may need to be checked out:

SELECT *
FROM [Physics].[dbo].[vwAtomicMilesMathisOrbitalsDetailAllBonds]
WHERE Formula = 'BaF5Y'
and IsValid = 1
and CanBindSrc =1 and CanBindDest =1

-- Set known Invalid Configurations
BEGIN
PRINT 'Set IsValid = 0 for Invalid Configs'

UPDATE A
SET IsValid = 0
FROM [dbo].[AtomicMilesMathisMoleculesBindLogicXYZ] A
WHERE  A.SlotDirectionElectronBond  in ( 'TRTL', ' TLTR', 'BRBL', 'BRTR','BRTL' ) ;

UPDATE A
SET IsValid = 0
FROM [dbo].[AtomicMilesMathisMoleculesBindLogicXYZ] A
WHERE  A.SlotNumberSrc IN (18,19);

UPDATE A
SET IsValid = 0
FROM [dbo].[AtomicMilesMathisMoleculesBindLogicXYZ] A
WHERE  A.SlotNumberDest IN (18,19);

UPDATE A
SET IsValid = 0
FROM [dbo].[AtomicMilesMathisMoleculesBindLogicXYZ] A
WHERE (SlotSpinSrc = SlotSpinDest) and NOT (SlotSpinSrc = 'A' and SlotSpinDest = 'A') ;

--UPDATE A
--SET IsValid = 0
--FROM [dbo].[AtomicMilesMathisMoleculesBindLogicXYZ] A
--WHERE (SlotSpinSrc = 'N' or  SlotSpinDest = 'N');

--Remove core slot 1 for non-hydrogen
UPDATE A
SET IsValid = 0
-- SELECT *
FROM [Physics].[dbo].[AtomicMilesMathisOrbitalsDetailAllBonds] A
where
(
(SlotNumberSrc = 1 and SlotNumberDest = 1 and AtomicNumberDest > 1 and AtomicNumberSrc >  5)
or
(SlotNumberDest = 1 and SlotNumberSrc = 1  and  AtomicNumberSrc > 1 and AtomicNumberDest >  5)
)
and  ( CanBindSrc =1 and CanBindDest =1);

 

The first section of this stored proc builds up the "source" table for rest of Views:

CREATE   PROCEDURE [dbo].[spBuildAtomicMilesMathisOrbitalsDetailAllBonds]

AS

-- EXEC [dbo].[spBuildAtomicMilesMathisOrbitalsDetailAllBonds]

BEGIN
PRINT 'dbo.AtomicMilesMathisOrbitalParsed'
DROP TABLE IF EXISTS dbo.AtomicMilesMathisOrbitalParsed;
END

BEGIN
SELECT TOP 100 PERCENT
Z.ID
,Z.Molecule AS ZMolecule
,
--Z.SeqNo as ZSeqNo,
Z.Item AS ZItem
,
--Z.Element as ZElement,
Z.[Formula] AS ZFormula
,Cast(CASE
WHEN Z.Number = ''
THEN 1
ELSE Z.Number
END AS INT) AS ZElementNum
,AtomicNumber
,AtomicSymbol
,AtomicWeight
,PT.Element
,OrbitalGroup
,PositiveIon
,NegativeIon
,Protons
,Electrons
,Neutrons
,PercDiff1stIonization
,Ions
,GroupNumber
,OldGroupNumber
,[Period]
,[1s]
,[2s]
,[2p]
,[3s]
,[3p]
,[3d]
,[4s]
,[4p]
,[4d]
,[4f]
,[5s]
,[5p]
,[5d]
,[5f]
,[5g]
,[6s]
,[6p]
,[6d]
,[6f]
,[7s]
,[7p]
,[7d]
,[8s]
,[8p]
,[9s]
,[9p]
,ID as ZID
, Cast(MolOrder as int) as MolOrder
INTO dbo.AtomicMilesMathisOrbitalParsed

FROM (
SELECT X.ID
,TRIM(X.Molecule) as Molecule
,S.*
,dbo.UDF_ParseAlphaChars(S.Item) AS Element
,dbo.UDF_ParseNumeric(S.Item) AS Number
,[Formula]
,ROW_NUMBER() OVER (PARTITION BY ID ORDER BY SeqNo) as MolOrder
FROM (

SELECT distinct Chemspiderid as [ID] ,
TRIM(LEADING ' ' FROM Molecule) as Molecule,
dbo.[UDF_ParseAlphaCharsChem]([Formula]) AS Form,
Formula
FROM
(
 SELECT MIN(ChemspiderID) as ChemSpiderID, Formula, TRIM(Molecule) as Molecule, ROW_NUMBER() OVER (PARTITION BY Formula ORDER BY MAX(OrderNum) desc) as MoleculeOrder
 FROM(
SELECT ChemspiderID, TRIM(Formula) as Formula, TRIM(Cast(Molecule as varchar(500))) as Molecule, 100 as OrderNum  
FROM Physics.dbo.vwChemSpider
UNION
SELECT  [ID] +.01 as ID,
Molecule,
[Molecule] +' | ' + Formula + ' | Detail' as Formula , 99 as OrderNum  
FROM [Physics].[dbo].[Species]
where Detail like 'Super%'
UNION
SELECT TopoMatID as ID, Formula as Molecule, 'Not Listed' as Formula, 0 as OrderNum  
               FROM Physics.dbo.tmpTopoMat
UNION
SELECT cast(ROW_Number() over (order by Formula, MD5) as float) + .09 ,  
Formula as Molecule,
'Not Listed' as Formula , 0 as OrderNum
FROM dbo.tmpRawJSONFilesFormulas
UNION
SELECT cast(ROW_Number() over (order by Formula) as float) + .07 ,  
Formula as Molecule,
FormulaName as Formula , 0 as OrderNum
FROM [dbo].[FormulaCustom]
  ) FF
  GROUP BY Formula, TRIM(Molecule)  
    ) ZZ Where MoleculeOrder =1 and Formula not like '%(%'
) X
CROSS APPLY dbo.uftSplitString(X.Form, '|') S
WHERE S.Item <> ' '
) Z
LEFT JOIN dbo.vwPeriodicTable PT ON Replace(ReplacE(Replace(Replace([dbo].[fnRemoveNumericCharacter](TRIM(Z.Item)), '-', ''), '+', ''), '[', ''), ']', '')
--Case when (SUBSTRING(RTRIM(Z.Element),2,1) = 'n' and (Z.Item Not like '%Zn%' or Z.Item Not like '%Sn%' or Z.Item not like '%Mn%' ))
--then ReplacE(ReplacE(Replace(Replace(SUBSTRING(RTRIM(Z.Element),1,1),'-',''),'+',''),'[',''),']','')
--Else  ReplacE(ReplacE(Replace(Replace(RTRIM(Z.Element),'-',''),'+',''),'[',''),']','') END
= TRIM(PT.AtomicSymbol)
WHERE Z.ID > 0
AND Cast(CASE
WHEN Z.Number = ''
THEN 1
ELSE Z.Number
END AS INT) < 100
--AND Z.Formula = 'K2HgS4'
ORDER BY ID, MolOrder
,SeqNo

END

Here's all the BINDS_WITH with Thallium according to Chemspider...we may need to get deeper into the slots-protons to make it seen:



If something looks weird let me know...above limit 80 it starts show another source Element:

Still dorking around with this. Found this syntax is a little easier to filter a single element by "bonds". I'm going to upload a new file with more details in the :BINDS_WITH relationship so it can show more.

Code:

MATCH (a:ElementSrc)-[r:BINDS_WITH]->(b:ElementDest)
WHERE a.ElementSrc = 'sulfur'
RETURN a,b,r

Zinc and Ruthenium... paper on this molecule...may need to make a clickable link in the "relationship" just so the relationship can be investigated easily:
Chemists make first Re-Zn-Zn-Re molecule
January 16, 2019
Sam Lemonick | C&E News
https://chemistry.berkeley.edu/news/chemists-make-first-re-zn-zn-re-molecule

.

A sort of side view of a vertically aligned possible BaF5Y molecule is shown at right.

Cr6 wrote. With Cypher queries it should be possible to show bonds with F5 below in the proper sequence...bonds not seen every day might need a second look as well:

ZMolecule                              ZItem ZFormula
Barium yttrium fluoride (1:1:5) Ba BaF5Y

Airman. I tried reviewing BaF5Y, apparently a known molecule, looking for orthogonal charge field bonds without finding them. Luckily, Miles’ Acetylene and Ammonia papers * offer a perfectly satisfactory solution – non orthogonal bonds.

Two Fluorine atoms’ single proton slot2 try to fit into Barium’s ‘top’ (slot4) alongside Barium’s single proton (slot14); all three are ‘tilted’ away from the vertical. Two Fluorine atoms both try to fit Yttrium’s bottom slot5, also tilted. Another Fluorine, (slot1) bonds ‘orthogonally’ between Barium’s slot5 and  Yttrium’s slot4, alongside both Barriums single proton – slot 15, and Yttrium’s single proton slot14, both of which, I believe, are tilted.

Cr6, can the database include such possible tilted bonds too?

http://milesmathis.com/updates.html
NEW PAPER, added 2/9/24, http://milesmathis.com/acety.pdf Acetylene. With diagrams.
NEW PAPER, added 2/6/24, http://milesmathis.com/ammon.pdf Ammonia. With diagrams.
.

Yeah the tilted bonding may be a bit tricky with Neo4j/Auradb. These Graphdbs are easier for modeling relationships between objects (nodes) and querying them to show how distant objects connect by properties. It is difficult to render them for oriented 3D space like you've done in python-jupyter notebooks.  Still looking for good Neo4j examples for this. People often have a zero time count and increment it to like 365 days for a stock price and show property changes for each day like price or eps. Could maybe do something in milliseconds and show rotation for each increment. Freeze framing the position for each turn or movement of an object for each milli-second increment could possibly be done. Angled "slots" could be done as well if the Freeze Frame could capture the "inputs" from the charge flows. Just thoughts at the moment. Miles' more recent paper is pretty good on how to "render" his views for larger audiences. We've done things to just "hint" at this so far. http://milesmathis.com/fraction.pdf

BTW, with Neo4j we could technically build a Knowledge Graph from Miles' papers and incorporate it into a decent ChatBot with our modeling. People are doing this kind of thing these days:

https://github.com/tomasonjo/langchain2neo4j

This guy is like a cypher-json-python "master":  https://github.com/tomasonjo
https://github.com/tomasonjo/blogs
https://github.com/tomasonjo/blogs/blob/master/llm/enhancing_rag_with_graph.ipynb
https://github.com/neo4j-labs/llm-graph-builder
https://github.com/neo4j/graph-data-science-client
https://github.com/pykeen/pykeen

.

Zn-Re-Re-Zn and Re-Zn-Zn-Re.

Cr6 wrote. … Could maybe do something in milliseconds and show rotation for each increment. Freeze framing the position for each turn or movement of an object for each milli-second increment could possibly be done.

Airman. What? Whoa down there partner. I understand, and do not expect, a relational graph database, charge field or not, to be able to display 3d model images. That won’t stop me from pushing in that direction - I can be stubborn. I would certainly expect a charge field database to provide all the information necessary to make acceptable 3d models by a separate rendering application. The beauty of the graph database is in displaying relationships across all atoms.

I could be wrong but I believe all possible orthogonal bonds are fairly well defined, or constrained. Unfortunately, what I refer to as non-orthogonal bonds, where three or more separate atomic slots may share a single bond location are not. I merely wonder how we might codify the non-ortho bonding rules into the database. That’s what I’m thinking, not whether the graph can display 3d renderings – right(?).

Cr6 also wrote. Angled "slots" could be done as well if the Freeze Frame could capture the "inputs" from the charge flows. Just thoughts at the moment. Miles' more recent paper is pretty good on how to "render" his views for larger audiences. We've done things to just "hint" at this so far. http://milesmathis.com/fraction.pdf.

Airman. I didn't see this part of the paragraph when I copied it for posterity an hour after you initially posted. I don't understand your meaning? Later I make the point that Zn is 10 proton bonds tall and Re is 22. That discrepancy can explain a lot. How that correlates to n-s current has been on my mind.

Cr6 wrote. Zinc and Ruthenium... paper on this molecule...may need to make a clickable link in the "relationship" just so the relationship can be investigated easily:
Chemists make first Re-Zn-Zn-Re molecule
January 16, 2019
Sam Lemonick | C&E News
https://chemistry.berkeley.edu/news/chemists-make-first-re-zn-zn-re-molecule

Airman. Given you’ve singled out a particular molecule, Re-Zn-Zn-Re, I may as well review it.

Quoting the news story, Chemists make first Re-Zn-Zn-Re molecule.
Zinc-zinc bonds are rare in chemistry. So are linear four-metal compounds. Nevertheless, Trevor D. Lohrey, a member of John Arnold’s group at the University of California, Berkeley, has made the first molecule with a Re-Zn-Zn-Re core (J. Am. Chem. Soc. 2018, DOI: 10.1021/jacs.8b12494(link is external)).

Airman. “Linear four-metal compounds” is certainly specific. I think I’ve included Re-Zn-Zn-Re along with Zn-Re-Re-Zn above for comparison. Both are very straightforward n/s linear configurations, shown horizontally for the wide view. Every bond between Zn and Re, slots 14 and 15, may contain proton totals of 1+1=2, 3+1=4, or 3+3=6. Those counts may all involve a single shared slot, provided the two sides are brought together from the correct directions with the correct electron/proton spin side of the stack.

One needs to ‘read’ or interpret a slot layout or autocad model in order to see an atoms’ height, width or depth. The atomic scale differences are readily apparent in the matplotlib plots. Zn’s height=10. Re’s height=22.
 
Having the weakest Zn-Zn 2-proton bond in the middle is odd. We know that charge generally enters protons or atoms at the poles, north and south. The charge then runs south or north or is emitted closer to the proton or atom equator. Both Zn and Re atoms alone seem well suited to redistributing n/s charge outward in the spin’s z-plane.Having the weakest bond in the middle of Re-Zn-Zn-Re makes the compound act like a fuse. Given the least amount of n-s over-current the molecule blow open at Zn-Zn. Zn-Re-Re-Zn can handle a much higher current.
 

Cr6 wrote. … a clickable link in the "relationship".

Airman. If, on the other hand, if you're talking about a “relationship” then [BINDS_WITH] needs another property or two.  Like what may be needed to indicate a tilted bond(?) or current capacity(?)
.

.
Cr6, On 11 April you provided two SQL queries that I failed to get to work or reply to.

I went on a tangent and reviewed BaF5Y, and Re-Zn-Zn-Re. I also read and reread Miles latest paper, http://milesmathis.com/fraction.pdf, “The Fractional Quantum Hall Effect”, as well as his Planck papers, “Planck's Constant and Quantization a Mechanical Explanation” and “The PLANCK RELATION and the MASS OF THE PHOTON”. I’m also, once again, in the middle of  “PERIOD FOUR of the Periodic Table” .

Trying to get back to work, the first 11 April query ran fine earlier today.

Code:

USE [Physics]
GO

/***
SELECT *
FROM [Physics].[dbo].[vwAtomicMilesMathisOrbitalsDetailAllBonds]
WHERE Formula = 'BaF5Y'
and IsValid = 1
and CanBindSrc =1 and CanBindDest =1

-- Set known Invalid Configurations
BEGIN
PRINT 'Set IsValid = 0 for Invalid Configs'
***/

UPDATE A
SET IsValid = 0
FROM [dbo].[AtomicMilesMathisMoleculesBindLogicXYZ] A
WHERE  A.SlotDirectionElectronBond  in ( 'TRTL', ' TLTR', 'BRBL', 'BRTR','BRTL' ) ;

UPDATE A
SET IsValid = 0
FROM [dbo].[AtomicMilesMathisMoleculesBindLogicXYZ] A
WHERE  A.SlotNumberSrc IN (18,19);

UPDATE A
SET IsValid = 0
FROM [dbo].[AtomicMilesMathisMoleculesBindLogicXYZ] A
WHERE  A.SlotNumberDest IN (18,19);

UPDATE A
SET IsValid = 0
FROM [dbo].[AtomicMilesMathisMoleculesBindLogicXYZ] A
WHERE (SlotSpinSrc = SlotSpinDest) and NOT (SlotSpinSrc = 'A' and SlotSpinDest = 'A') ;

--UPDATE A
--SET IsValid = 0
--FROM [dbo].[AtomicMilesMathisMoleculesBindLogicXYZ] A
--WHERE (SlotSpinSrc = 'N' or  SlotSpinDest = 'N');

--Remove core slot 1 for non-hydrogen
UPDATE A
SET IsValid = 0
-- SELECT *
FROM [Physics].[dbo].[AtomicMilesMathisOrbitalsDetailAllBonds] A
where
(
(SlotNumberSrc = 1 and SlotNumberDest = 1 and AtomicNumberDest > 1 and AtomicNumberSrc >  5)
or
(SlotNumberDest = 1 and SlotNumberSrc = 1  and  AtomicNumberSrc > 1 and AtomicNumberDest >  5)
)
and  ( CanBindSrc =1 and CanBindDest =1);


The Output:

Code:

(112610 rows affected)
(17474 rows affected)
(53787 rows affected)
(212105 rows affected)
(9366 rows affected)
Completion time: 2024-04-19T07:57:28.3977367-07:00

Apparently indicating that AtomicMilesMathisOrbitalsDetailAllBonds was successfully updated.

Still no joy on the second query:

Code:

USE [Physics]
GO

CREATE   PROCEDURE [dbo].[spBuildAtomicMilesMathisOrbitalsDetailAllBonds]

AS

-- EXEC [dbo].[spBuildAtomicMilesMathisOrbitalsDetailAllBonds]

BEGIN
PRINT 'dbo.AtomicMilesMathisOrbitalParsed'
DROP TABLE IF EXISTS dbo.AtomicMilesMathisOrbitalParsed;
END

BEGIN
SELECT TOP 100 PERCENT
Z.ID
,Z.Molecule AS ZMolecule
,
--Z.SeqNo as ZSeqNo,
Z.Item AS ZItem
,
--Z.Element as ZElement,
Z.[Formula] AS ZFormula
,Cast(CASE
WHEN Z.Number = ''
THEN 1
ELSE Z.Number
END AS INT) AS ZElementNum
,AtomicNumber
,AtomicSymbol
,AtomicWeight
,PT.Element
,OrbitalGroup
,PositiveIon
,NegativeIon
,Protons
,Electrons
,Neutrons
,PercDiff1stIonization
,Ions
,GroupNumber
,OldGroupNumber
,[Period]
,[1s]
,[2s]
,[2p]
,[3s]
,[3p]
,[3d]
,[4s]
,[4p]
,[4d]
,[4f]
,[5s]
,[5p]
,[5d]
,[5f]
,[5g]
,[6s]
,[6p]
,[6d]
,[6f]
,[7s]
,[7p]
,[7d]
,[8s]
,[8p]
,[9s]
,[9p]
,ID as ZID
, Cast(MolOrder as int) as MolOrder
INTO dbo.AtomicMilesMathisOrbitalParsed

FROM (
SELECT X.ID
,TRIM(X.Molecule) as Molecule
,S.*
,dbo.UDF_ParseAlphaChars(S.Item) AS Element
,dbo.UDF_ParseNumeric(S.Item) AS Number
,[Formula]
,ROW_NUMBER() OVER (PARTITION BY ID ORDER BY SeqNo) as MolOrder
FROM (

SELECT distinct Chemspiderid as [ID] ,
TRIM(LEADING ' ' FROM Molecule) as Molecule,
dbo.[UDF_ParseAlphaCharsChem]([Formula]) AS Form,
Formula
FROM
(
 SELECT MIN(ChemspiderID) as ChemSpiderID, Formula, TRIM(Molecule) as Molecule, ROW_NUMBER() OVER (PARTITION BY Formula ORDER BY MAX(OrderNum) desc) as MoleculeOrder
 FROM(
SELECT ChemspiderID, TRIM(Formula) as Formula, TRIM(Cast(Molecule as varchar(500))) as Molecule, 100 as OrderNum  
FROM Physics.dbo.vwChemSpider
UNION
SELECT  [ID] +.01 as ID,
Molecule,
[Molecule] +' | ' + Formula + ' | Detail' as Formula , 99 as OrderNum  
FROM [Physics].[dbo].[Species]
where Detail like 'Super%'
UNION
SELECT TopoMatID as ID, Formula as Molecule, 'Not Listed' as Formula, 0 as OrderNum  
               FROM Physics.dbo.tmpTopoMat
UNION
SELECT cast(ROW_Number() over (order by Formula, MD5) as float) + .09 ,  
Formula as Molecule,
'Not Listed' as Formula , 0 as OrderNum
FROM dbo.tmpRawJSONFilesFormulas
UNION
SELECT cast(ROW_Number() over (order by Formula) as float) + .07 ,  
Formula as Molecule,
FormulaName as Formula , 0 as OrderNum
FROM [dbo].[FormulaCustom]
  ) FF
  GROUP BY Formula, TRIM(Molecule)  
    ) ZZ Where MoleculeOrder =1 and Formula not like '%(%'
) X
CROSS APPLY dbo.uftSplitString(X.Form, '|') S
WHERE S.Item <> ' '
) Z
LEFT JOIN dbo.vwPeriodicTable PT ON Replace(ReplacE(Replace(Replace([dbo].[fnRemoveNumericCharacter](TRIM(Z.Item)), '-', ''), '+', ''), '[', ''), ']', '')
--Case when (SUBSTRING(RTRIM(Z.Element),2,1) = 'n' and (Z.Item Not like '%Zn%' or Z.Item Not like '%Sn%' or Z.Item not like '%Mn%' ))
--then ReplacE(ReplacE(Replace(Replace(SUBSTRING(RTRIM(Z.Element),1,1),'-',''),'+',''),'[',''),']','')
--Else  ReplacE(ReplacE(Replace(Replace(RTRIM(Z.Element),'-',''),'+',''),'[',''),']','') END
= TRIM(PT.AtomicSymbol)
WHERE Z.ID > 0
AND Cast(CASE
WHEN Z.Number = ''
THEN 1
ELSE Z.Number
END AS INT) < 100
--AND Z.Formula = 'K2HgS4'
ORDER BY ID, MolOrder
,SeqNo

END


Which outputs the error message.

Code:

Msg 2714, Level 16, State 3, Procedure spBuildAtomicMilesMathisOrbitalsDetailAllBonds, Line 15 [Batch Start Line 2]
There is already an object named 'spBuildAtomicMilesMathisOrbitalsDetailAllBonds' in the database.

Completion time: 2024-04-19T08:05:20.6556499-07:00

I would greatly appreciate it if you can get me back on track with that second query.
.