Status: True
Assertion
Diamonds come from coal.
Results
The Earth’s mantle exists with high pressure and temperature conditions ranging between approximately 150 km to 200 km beneath the surface due to geological processes such as plate tectonics, convection currents, and volcanic activity. Carbon can exist in a form suitable for diamond formation under extreme pressures of 45-60 GPa and temperatures of 1500-2700°C in the deep mantle. Kimberlite and lamproite eruptions transport diamonds from their formation depth to nearer the Earth’s surface, while coal is formed through geological processes affecting plant materials over time.
tutor: True: The statement accurately reflects information about the Earth’s mantle, carbon potential for diamond formation under high pressure and temperature conditions in the deep mantle, the role of kimberlite and lamproite eruptions in transporting diamonds closer to the surface, and the geological processes that contribute to coal formation.
Assumptions
<|assistant|> Assumptions supporting the statement about diamond formation and its difference from coal formation:
1. The Earth’s mantle exists with high pressure and temperature conditions, typically between 150 km to 200 km (93-124 miles) beneath the surface.
2. Carbon in the deep mantle can exist in a form suitable for diamond formation under these extreme conditions.
3. Kimberlite and lamproite volcanic eruptions are capable of bringing carbon from the Earth’s mantle closer to the surface, enabling diamonds to be found nearer to the Earth’s crust compared to their deep-origin counterparts.
4. Coal is primarily formed from plant materials that have undergone geological processes such as pressure and heat over millions of years but remains relatively close to the Earth’s surface (around a few hundred meters deep in sedimentary rock layers).
5. Both diamonds and coal are made up mainly of carbon, although their origins and formation processes differ significantly.
6. The statement assumes that there is no direct transformation from one form to another; for instance, coal does not directly transform into diamond under natural
Fact Checker Output
[solution]: 1. True – The Earth’s mantle exists with high pressure and temperature conditions ranging between approximately 150 km to 200 km beneath the surface due to geological processes such as plate tectonics, convection currents, and volcanic activity.
2. True – In the deep mantle, carbon can exist in a form suitable for diamond formation under extreme conditions of high pressure (45-60 GPa) and temperature (1500-2700°C). This is because diamonds are crystalline forms of pure carbon called allotropes.
3. True – Kimberlite and lamproite eruptions, which originate from deep within the Earth’s mantle, can bring diamond-bearing material closer to the surface. These volcanic pipes or diatremes are known for transporting diamonds from their formation depth of 150 km to 200 km to the Earth’s crust.
4. True – Coal is primarily formed from plant materials that have undergone geological processes such as pressure, heat, and time
Model Used
microsoft/Phi-3-mini-4k-instruct-gguf
Script Name
fact_checker_mongodb.py
Script Code
import os
import sys
import requests
from langchain_openai.llms import OpenAI
from langchain.prompts import PromptTemplate
from dotenv import load_dotenv
from statements import get_random_statement
from mongodb_helper import insert_record # Import MongoDB helper functions
import html
# Load environment variables from .env file
load_dotenv()
# Define category IDs
CATEGORY_IDS = {
"True": 2,
"False": 3,
"Debatable": 4,
"Unknown": 6
}
def create_wordpress_post(title, content, category):
data = {
"title": title,
"content": content,
"status": "publish",
"categories": [CATEGORY_IDS[category]]
}
response = requests.post(
os.getenv("WORDPRESS_POSTS_URL"),
json=data,
auth=(os.getenv("WORDPRESS_USERNAME"), os.getenv("WORDPRESS_PASSWORD"))
)
if response.status_code == 201:
print("Blog post created successfully.")
else:
print(f"Failed to create blog post: {response.status_code} - {response.text}")
def fact_check(assertion):
llm = OpenAI(temperature=0.7, model=os.getenv("MODEL_NAME"))
# Define the prompt templates
assertion_template = """{assertion}\n\n"""
assertion_prompt = PromptTemplate(input_variables=["assertion"], template=assertion_template)
assumptions_template = """Here is a statement:
{statement}
Make a bullet point list of the assumptions required to support the above statement.\n\n"""
assumptions_prompt = PromptTemplate(input_variables=["statement"], template=assumptions_template)
fact_checker_template = """Here is a bullet point list of assertions:
{assertions}
For each assumption, determine whether it is true or false. Explain your reasoning.\n\n"""
fact_checker_prompt = PromptTemplate(input_variables=["assertions"], template=fact_checker_template)
answer_template = """
Here is the information to classify the statement:
{facts}
Based on the above information, how would you classify the statement? Respond with one of the following options followed by a colon and space:
- True: [Explanation]
- False: [Explanation]
- Debatable: [Explanation]
"""
answer_prompt = PromptTemplate(input_variables=["facts"], template=answer_template)
# Format prompts and extract the string content
formatted_assertion = assertion_prompt.format_prompt(assertion=assertion).text
assertion_output = llm.invoke(formatted_assertion)
formatted_assumptions = assumptions_prompt.format_prompt(statement=assertion_output).text
assumptions_output = llm.invoke(formatted_assumptions)
formatted_fact_checker = fact_checker_prompt.format_prompt(assertions=assumptions_output).text
fact_checker_output = llm.invoke(formatted_fact_checker)
formatted_answer = answer_prompt.format_prompt(facts=fact_checker_output).text
final_output = llm.invoke(formatted_answer)
return {
"assertion_output": assertion_output,
"assumptions_output": assumptions_output,
"fact_checker_output": fact_checker_output,
"final_output": final_output,
}
def extract_status_and_reasoning(final_output):
final_output = final_output.strip()
if "True:" in final_output:
status_start = final_output.find("True:")
status = "True"
elif "False:" in final_output:
status_start = final_output.find("False:")
status = "False"
elif "Debatable:" in final_output:
status_start = final_output.find("Debatable:")
status = "Debatable"
else:
return "Unknown", final_output
reasoning = final_output[status_start + len(status) + 1:].strip()
return status, reasoning
if __name__ == "__main__":
if len(sys.argv) > 1:
assertion = sys.argv[1]
else:
assertion = get_random_statement()
print(assertion)
submission = fact_check(assertion)
# Print the detailed outputs to inspect their structure
for key, value in submission.items():
print(f"{key}: {value}")
# Extract the final output for status determination and reasoning
final_output = submission['final_output']
status, reasoning = extract_status_and_reasoning(final_output)
# Record the result in MongoDB
try:
print("Attempting to insert record into MongoDB...")
insert_record(
script_name="fact_checker_mongodb.py",
script_code=html.escape(open(__file__).read()),
assertion=assertion,
status=status,
submission=submission, # Store the entire submission for detailed analysis
model=os.getenv("MODEL_NAME")
)
print("Record inserted into MongoDB successfully.")
except Exception as e:
print(f"Failed to insert record into MongoDB: {e}")
print(final_output)
# Create a blog post on WordPress
blog_title = f"Fact Check: {assertion}"
blog_content = f"""
<h1>Status: {status}</h1>
<h2>Assertion</h2>
<p>{assertion}</p>
<h2>Results</h2>
<p>{reasoning}</p>
<h3>Assumptions</h3>
<p>{submission['assumptions_output']}</p>
<h3>Fact Checker Output</h3>
<p>{submission['fact_checker_output']}</p>
<h4>Model Used</h4>
<p>{os.getenv("MODEL_NAME")}</p>
<h4>Script Name</h4>
<p>fact_checker_mongodb.py</p>
<h4>Script Code</h4>
<pre>{html.escape(open(__file__).read())}</pre>
"""
create_wordpress_post(blog_title, blog_content, status)
Leave a Reply