Task:
Generate a Cypher query for a Neo4j graph database.
Instructions:
Use only the provided relationship types and properties in the schema.
Do not use any other relationship types or properties that are not provided or defined. Do not explain anything. Ensure to specify the relationships and nodes to be used from the provided schema.
Schema:
Node properties are the following:
`Hospital {state_name: STRING, name: STRING, id: INTEGER},Payer {name: STRING, id: INTEGER},Physician {salary: FLOAT, dob: STRING, grad_year: STRING, name: STRING, school: STRING, id: INTEGER},Patient {dob: STRING, id: INTEGER, blood_type: STRING, sex: STRING, name: STRING},Visit {status: STRING, discharge_date: STRING, admission_type: STRING, test_results: STRING, admission_date: STRING, room_number: INTEGER, id: INTEGER, chief_complaint: STRING, treatment_description: STRING, diagnosis: STRING},Review {hospital_name: STRING, patient_name: STRING, embedding: LIST, text: STRING, physician_name: STRING, id: INTEGER}`
Relationship properties are the following:
`COVERED_BY {service_date: STRING, billing_amount: FLOAT}`
The relationships are the following:
`(:Hospital)-[:EMPLOYS]->(:Physician),(:Physician)-[:TREATS]->(:Visit),(:Patient)-[:HAS]->(:Visit),(:Visit)-[:AT]->(:Hospital),(:Visit)-[:COVERED_BY]->(:Payer),(:Visit)-[:WRITES]->(:Review)`
Note:
Do not use undefined relationship types. Do not use undefined properties.
Do not include any explanations or apologies in your responses. 
Convert information from the question to those listed in the schema, for example, if the question provides a year, convert it into the yyyy-mm-dd date.
Convert relationship types from the question to only those by the schema. For example use the correct existing relationship type `[:COVERED_BY]` do not use non-existent `[:BILLED_TO]`.
Convert property from the question to only those by the schema. For example, use the correct existing property `admission_date`. Do not use non-existent `visit_date`. Also use correct properties, for example `billing_amount` property is part of the `COVERED_BY` relationship, not the `Visit` node.
Do not respond to any questions that might ask anything other than for you to construct a Cypher Query. 
Do not include any text except the generated single Cypher Query. Ensure the direction of the relationship is correct in your query. 
Ensure you alias both entities and relationships properly. Do not create a query that would modify, add to or delete from the database, create read-only query.
Ensure to alias all statements that follow as with statement (e.g. WITH v as visit, c.billing_amount as billing_amount)
If you need to divide numbers, ensure to filter the denominator to be non-zero.

Read Query Structure with the Baseline for pattern search operations:
`[USE]
[MATCH [WHERE]]
[OPTIONAL MATCH [WHERE]]
[WITH [ORDER BY] [SKIP] [LIMIT] [WHERE]]
RETURN [ORDER BY] [SKIP] [LIMIT]`
MATCH is often coupled to a WHERE part which adds restrictions, or predicates, to the MATCH patterns, making them more specific. The predicates are part of the pattern description, and should not be considered a filter applied only after the matching is done. This means that WHERE should always be put together with the MATCH clause it belongs to.
```Cypher
# Match all nodes and return all nodes, allows you to specify the patterns Neo4j will search for in the database
MATCH (n)
RETURN n AS node
```
```Cypher
# Match all Patient nodes with an HAS relationship connected to a Visit node, and return the name of the visitOrs.
MATCH (n:Patient)-[:HAS]->(:Visit)
RETURN n.name AS visitOrs
```
```Cypher
# Bind a path pattern to a path variable, and return the path pattern.
MATCH p=(:Patient)-[:HAS]->(:Visit)
RETURN p AS path
```
```Cypher
# WHERE can appear in a MATCH or OPTIONAL MATCH clause. It can also filter the results of a WITH clause.
MATCH (n:Label)-->(m:Label)
WHERE n.property <> $value
RETURN n, m
```
```Cypher
# A label expression can be used as a predicate in the WHERE clause.
MATCH (n)
WHERE n:A|B
RETURN n.name AS name
```
```Cypher
# A relationship type expression can be used as a predicate in the WHERE clause.
MATCH (n:Label)-[r]->(m:Label)
WHERE r:R1|R2
RETURN r.name AS name
```
```Cypher
# WHERE can appear inside a MATCH clause.
# 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
WITH 30 AS minAge
MATCH (a:Patient WHERE a.name = 'Andy')-[:KNOWS]->(b:Patient WHERE b.age > minAge)
RETURN b.name
```
```Cypher
# WHERE can appear inside a pattern comprehension statement.
MATCH (a:Patient {name: 'Andy'})
RETURN [(a)-->(b WHERE b:Patient) | b.name] AS friends
```
```Cypher
# A relationship type expression can be used as a predicate in a WHERE clause.
# WITH can be used to introduce new variables containing the results of expressions
WITH 2000 AS minYear
MATCH (a:Patient)-[r:KNOWS WHERE r.since < minYear]->(b:Patient)
RETURN r.since
```
```Cypher
# Relationship pattern predicates can be used inside pattern comprehension.
WITH 2000 AS minYear
MATCH (a:Patient {name: 'Andy'})
RETURN [(a)-[r:KNOWS WHERE r.since < minYear]->(b:Patient) | r.since] AS years
```
```Cypher
# Return the value of all variables.
MATCH (n:Label)-[r]->(m:Label)
RETURN *
```
```Cypher
# Use alias for result column name.
MATCH (n:Label)-[r]->(m:Label)
RETURN n AS node, r AS rel
```
```Cypher
# Return unique rows.
MATCH (n:Patient)-[r:KNOWS]-(m:Patient)
RETURN DISTINCT n AS node
```
```Cypher
# Sort the result. The default order is ASCENDING.
MATCH (n:Label)-[r]->(m:Label)
RETURN n AS node, r AS rel
ORDER BY n.name
```
```Cypher
# Sort the result in DESCENDING order.
MATCH (n:Label)-[r]->(m:Label)
RETURN n AS node, r AS rel
ORDER BY n.name DESC
```
```Cypher
# Skip the 10 first rows, for the result set.
MATCH (n:Label)-[r]->(m:Label)
RETURN n AS node, r AS rel
SKIP 10
```
```Cypher
# Limit the number of rows to a maximum of 10, for the result set.
MATCH (n:Label)-[r]->(m:Label)
RETURN n AS node, r AS rel
LIMIT 10
```
```Cypher
# The number of matching rows. See aggregating functions for more.
MATCH (n:Label)-[r]->(m:Label)
RETURN count(*) AS nbr
```
```Cypher
# A label expression can be used in the WITH or RETURN statement.
MATCH (n)
RETURN n:A&B
```
```Cypher
# A relationship type expression can be used as a predicate in the WITH or RETURN statement.
MATCH (n:Label)-[r]->(m:Label)
RETURN r:R1|R2 AS result
```
```Cypher
# The WITH syntax is similar to RETURN. It separates query parts explicitly, allowing Patients to declare which variables to carry over to the next part of the query.
MATCH (Patient)-[:KNOWS]-(friend)
WHERE Patient.name = $name
WITH Patient, count(friend) AS friends
WHERE friends > 10
RETURN Patient
```
```Cypher
# The WITH clause can use:
# ORDER BY, SKIP, LIMIT
WHERE
MATCH (Patient)-[:KNOWS]-(friend)
WITH Patient, count(friend) AS friends
ORDER BY friends DESC
SKIP 1
LIMIT 3
WHERE friends > 10
RETURN Patient
```
Examples:
This Query matches Patient nodes, calculates the age using the `duration.between` function, orders by age in descending order, and limits the result to the oldest patient.
```Cypher
# Who is the oldest patient and how old are they?
MATCH (p:Patient)
RETURN p.name AS oldest_patient,
       duration.between(date(p.dob), date()).years AS age
ORDER BY age DESC
LIMIT 1
```
This Query matches `Payer`, `Visit`, and `Physician` nodes, filters for the payer 'Cigna', sums the billing amounts, and orders by the total billed in ascending order, and limits the result to the physician who billed the least.
```Cypher
# Which physician has billed the least to Cigna.
MATCH (p:Payer)<-[c:COVERED_BY]-(v:Visit)-[t:TREATS]-(phy:Physician)
WHERE p.name = 'Cigna'
RETURN phy.name AS physician_name, SUM(c.billing_amount) AS total_billed
ORDER BY total_billed
LIMIT 1
```
```Cypher
# Which state had the largest percent increase in Cigna visits from 2022 to 2023?
MATCH (h:Hospital)<-[:AT]-(v:Visit)-[:COVERED_BY]->(p:Payer)
WHERE p.name = 'Cigna' AND v.admission_date >= '2022-01-01' AND
v.admission_date < '2023-12-31'
# 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.
WITH h.state_name AS state, COUNT(v) AS visit_count,
     SUM(CASE WHEN v.admission_date >= '2022-01-01' AND
     v.admission_date < '2023-01-01' THEN 1 ELSE 0 END) AS count_2022,
     SUM(CASE WHEN v.admission_date >= '2023-01-01' AND
     v.admission_date < '2023-12-31' THEN 1 ELSE 0 END) AS count_2023
WITH state, visit_count, count_2022, count_2023,
     (toFloat(count_2023) - toFloat(count_2022)) / toFloat(count_2022) * 100
     AS percent_increase
RETURN state, percent_increase
ORDER BY percent_increase DESC
LIMIT 1
```
```Cypher
# How many non-emergency patients in North Carolina have written reviews?
MATCH (r:Review)<-[:WRITES]-(v:Visit)-[:AT]->(h:Hospital)
WHERE h.state_name = 'NC' and v.admission_type <> 'Emergency'
RETURN count(*)
```
Steps to produce Cypher Query structure:
```Cypher
# billed each patient in 2024
MATCH (v:Visit)-[c:COVERED_BY]->(p:Payer)
WHERE v.admission_date >= '2024-01-01' AND v.admission_date < '2024-12-31' AND p.name IS NOT NULL
RETURN p.name AS Payer, SUM(c.billing_amount) AS total_billing_amount
```
MATCH Clause:
The relationship direction should reflect the correct flow from `Visit` to `Payer`, note the direction arrow `->`. For example use the relationship direction correctly matching the schema, which has `Visit` nodes connected to `Payer` nodes via `[:COVERED_BY]`, typically, a `Visit` would be covered by a `Payer`, not the other way around.
This part of the query matches `Visit` nodes connected to `Payer` nodes via the `COVERED_BY` relationship connection. It ensures that we are working with the correct nodes and relationships as per the schema.
Only one direction of Relationships is allowed if present: the connection arrow `->` goes from the `Visit` to the `Payer`.
```
MATCH (v:Visit)-[c:COVERED_BY]->(p:Payer)
```
WHERE Clause:
This clause filters the visits to include only those with an `admission_date` within the year 2022.
It also ensures that the payer's name is not null, for meaningful results.
```
WHERE v.admission_date >= '2022-01-01' AND v.admission_date < '2023-01-01' AND p.name IS NOT NULL
```
RETURN Clause:
This part returns the name of the payer and the total billing amount for the visits in 2022.
It correctly uses `SUM(c.billing_amount)` to aggregate the billing amounts from the `COVERED_BY` relationship.
```
RETURN p.name AS Payer, SUM(c.billing_amount) AS total_billing_amount
```
String category values:
Test results are one of: 'Inconclusive', 'Normal', 'Abnormal'
Visit statuses are one of: 'OPEN', 'DISCHARGED'
Admission Types are one of: 'Elective', 'Emergency', 'Urgent'
Payer names are one of: 'Cigna', 'Blue Cross', 'UnitedHealthcare', 'Medicare', 'Aetna'
A visit is considered open if its status is 'OPEN' and the discharge date is missing.
Use abbreviations when filtering on hospital states (e.g. "Texas" is "TX", "Colorado" is "CO", "North Carolina" is "NC", "Florida" is "FL", "Georgia" is "GA, etc.)
Ensure to use `IS NULL` or `IS NOT NULL` when analyzing missing properties.
Never return embedding properties in your query. You must never include the statement "GROUP BY" in your query. 
Ensure to alias all statements that follow as with statement (e.g. WITH v as visit, c.billing_amount as billing_amount)
If you need to divide numbers, ensure to filter the denominator to be non-zero. The output must be a valid Cypher query only.
Do not provide any explanation, only a single Cypher query.
The question is:
Total billing amount charged to each payer for 2022