update after review

Author: lidiazuin

modules/ROOT/pages/cypher/index.adoc

@@ -43,7 +43,7 @@ The "Query fundamentals" gives you a hands-on introduction to Cypher.
 Neo4j's graph model is composed of <<nodes>> and <<relationships>>, which may also have assigned <<properties>>.
 With nodes and relationships, you can build a graph that can express both simple and complex patterns.
 
-Pattern recognition is a key fundamental cognitive process, making Cypher, which utilizes pattern matching, intuitive and easy to learn.
+Pattern recognition is a key fundamental cognitive process, making Cypher, which utilizes pattern matching, more intuitive to learn.
 
 [#cypher-syntax]
 == Cypher syntax
@@ -61,7 +61,7 @@ link:https://www.youtube.com/watch?v=_dup3YOZSm8[What is Cypher?]
 endif::[]
 
 Cypher's constructs are based on English prose and iconography.
-This makes queries easy both to write and to read.
+It allows the user to get a natural language understanding while programming.
 
 .A graph example involving four nodes and three relationships.
 image::cypherintro-graph1.svg[role="popup-link",width=600]
@@ -77,7 +77,7 @@ Now, if you were to write this same information in Cypher, then it would look li
 (:Sally)-[:WORKS_FOR]->(:Neo4j)
 ----
 
-However, in order to have this information in the graph, first you need to represent it as nodes and relationships.
+With this query, you turn the information into nodes and relationships, which are the core elements of Cypher.
 
 === Nodes
 
@@ -93,17 +93,16 @@ The parentheses are a representation of the circles that compose the nodes in th
 
 ==== Node labels
 
-Nodes can be grouped together through a <<label>>.
-They work like tags and allow you to specify certain types of entities to look for or to create.
-Labels also help Cypher distinguish between entities and optimize execution for your queries.
+Nodes can be grouped together through a <<label>>, which is an component that works like tags and allows you to specify certain types of entities in your queries.
+Labels also help Cypher distinguish between nodes and optimize execution.
 
 In the example, both `Sally` and `John` are persons, so they get a `Person` label, `Graphs` gets a `Technology` label, and `Neo4j` is a `Company`:
 
 .Nodes grouped by labels. Note that `Sally`, `John`, `Graphs`, and `Neo4j` are now xref:cypher/index.adoc#cypher-properties[properties] instead.
 image::cypher-graph-nodes-arr.svg[role="popup-link",width=450]
 
-In a relational database context, this would be the same as telling SQL which table to look for the particular row.
-The same way you can tell SQL to query a person's information from a `Person` table, you can also tell Cypher to only check the `Person` label for that information.
+In a relational database context, this would be the same as using SQL to refer to a table that should be looked for a particular row.
+The same way you can use SQL to query a person's information from a `Person` table, you can also use Cypher to only check the `Person` label for that information.
 
 [CAUTION]
 ====
@@ -114,6 +113,7 @@ This can affect performance in very large graphs.
 ==== Node variables
 
 It is necessary to bind matched data entities to variables in order to reference them in subsequent clauses.
+If part of your query matches nodes that you need to reference in a later part of your query (i.e. in a link:https://neo4j.com/docs/cypher-manual/current/clauses/#reading-sub-clauses[subclause]), you can use *node variables*.
 
 Variables can be single letters or words, and should be written in lower-case.
 For example, if you want to bind all nodes labeled `Person` to the variable `p`, you write `(p:Person)`.
@@ -129,20 +129,15 @@ RETURN p
 [#cypher-relationships]
 === Relationships
 
-One of the benefits of graph databases is that you can store information about how elements (nodes) are related to each other in the form of relationships.
+Similarly to relational databases, graphs can also store information about how elements (nodes) are related to each other in the form of relationships.
 
-In Cypher, relationships are represented as square brackets and an arrow connecting two nodes (e.g. `(Node1)-[]->(Node2)`).
+In Cypher, relationships are represented as square brackets with an optional arrow to indicate the direction (e.g. `(Node1)-[]->(Node2)`).
 
 In the example, the lines containing `:LIKES`, `:IS_FRIENDS_WITH`, and `:WORKS_FOR` represent the relationship between the nodes:
 
 .Graph featuring nodes and relationships.
 image::cypherintro-graph1.svg[]
 
-[NOTE]
-====
-Remember to always put a colon in front of a relationship type.
-If you happen to forget it, and write a query such as `(:Person)-[LIKES]->(:Technology)`, `[LIKES]` will then represent a xref:cypher/index.adoc#_relationship_variables[relationship *variable*], not a relationship *type*.
-====
 
 ==== Relationship directions
 
@@ -196,6 +191,13 @@ In the previous example, the relationship types are:
 * `[:IS_FRIENDS_WITH]` - communicates that Sally _is friends with_ John.
 * `[:WORKS_FOR]` - communicates that Sally _works for_ Neo4j.
 
+[IMPORTANT]
+====
+Remember to always put a colon in front of a relationship type.
+If you write `(Person)-[LIKES]->(Technology)`, `[LIKES]` will represent a relationship *variable*, not a relationship *type*.
+In this case, since no relationship type is declared, Cypher's `RETURN` clause will search for all types of relationships in order to retrieve a result to your query.
+====
+
 ==== Relationship variables
 
 Variables can be used for relationships in the same way as for nodes. 
@@ -227,28 +229,19 @@ image::cypherintro-variables.svg[]
 3+d|Rows: 1
 |===
 
-Remember to always put a colon in front of a relationship type.
-If you happen to forget it, and write the query like this:
-
-[source,cypher]
-----
-(Person)-[LIKES]->(Technology)
-----
-
-`[LIKES]` will represent a relationship *variable*, not a relationship *type*.
-In this case, since no relationship type is declared, Cypher will search for all types of relationships in order to retrieve a result to your query.
-
 [#cypher-properties]
 === Properties
 
 Properties can be added both to nodes and relationships and be of a variety of data types.
 For a full list of values and types, see link:{docs-home}/cypher-manual/current/values-and-types/[Cypher manual -> Values and types].
 
-Another way to organize the data in the previous example would be to add a *property*, `name`, and `Sally` and `John` as *property values* on `Person`-labeled nodes:
+In the following example, `sally` and `john` are xref:cypher/index.adoc##_node_variables[variables] for `Person` nodes which contain a `name` property with the *property values* "Sally" and "John":
 
 .Graph example with node and relationship properties.
 image::cypherintro-properties.svg[]
 
+To add this info to the graph, you can use the following query:
+
 [source,cypher]
 ----
 CREATE (sally:Person {name:'Sally'})-[r:IS_FRIENDS_WITH]->(john:Person {name:'John'})
@@ -281,21 +274,29 @@ In order to *do* something with this pattern, such as adding it to or retrieving
 For example, you can add this information to the database using the link:{docs-home}/cypher-manual/current/clauses/create/[`CREATE`] clause:
 
 [source, cypher]
-----
+--
 CREATE (sally:Person {name: "Sally"})-[r:LIKES]->(t:Technology {type: "Graphs"})
-----
+--
 
 And once this data is written to the database, you can retrieve it with this pattern:
 
 [source, cypher]
-----
+--
 MATCH (sally:Person {name: "Sally"})-[r:LIKES]->(t:Technology {type: "Graphs"})
-RETURN p,r,t
-----
+RETURN sally,r,t
+--
 
-=== Patterns variables
+==== Pattern variables
 
 In the same way as nodes and relationships, you can also use variables for patterns.
+Considering the previous example, you can turn contain the whole pattern (`(Sally)-[:LIKES]->(Technology)`) inside a pattern by creating a variable (`p`) for it all:
+
+[source,cypher]
+--
+MATCH p = (sally:Person {name: "Sally"})-[r:LIKES]->(t:Technology {type: "Graphs"})
+RETURN p
+--
+
 For more information, refer to link:{docs-home}/cypher-manual/current/patterns/reference/[Cypher manual -> Patterns -> Syntax and Semantics].
 
 == Keep learning