Status: True

Assertion

The human stomach can dissolve razor blades.

Results

The assertion that a razor blade made from steel contains iron (Fe) is true because steel, being an alloy primarily composed of iron and carbon, has iron as its main component. Protective coatings on steel blades may offer some degree of resistance to corrosion but are unlikely to provide complete protection against the highly acidic gastric environment in the stomach. Gastric acid with a pH ranging from 1.5 to 3.5 is capable of reacting with many metals, including steel, leading to potential corrosion over time. However, without specific details on exposure duration and concentration, it’s challenging to predict the exact rate or extent of this process.

: True: A razor blade made from steel contains iron (Fe) because steel is an alloy predominantly composed of iron and carbon; protective coatings may offer partial resistance but cannot ensure absolute corrosion prevention in gastric acid conditions, which have a pH of 1.5 to 3.5 and can react with metals like steel.

: True: Steel razor blades contain iron (

Assumptions

<|assistant|> – The razor blade is made from steel, which contains iron (Fe).
– Steel blades used in disposable razors may have protective coatings that could react with gastric acid but are not guaranteed to prevent corrosion entirely.
– Gastric acid has a pH typically around 1.5 to 3.5, which is strong enough to potentially cause chemical reactions with certain metals.
– The razor blade is exposed to the conditions within the human stomach for an unspecified duration and concentration of hydrochloric acid present in gastric secretions.
– There are no other factors mitigating the corrosive effects of stomach acids on steel, such as protective barriers or the presence of buffering agents that could neutralize the acidity.
– The razor blade has not undergone any treatment to make it resistant to corrosion or is not coated with materials specifically designed to prevent dissolution in stomach acids (like ceramic coatings).
– The statement does not consider variations in individual gastric acid levels, which could influence the rate and extent of potential corrosion

Fact Checker Output

[Bob]: – True: The assertion that a razor blade made from steel contains iron (Fe) is true because steel is an alloy primarily composed of iron and carbon, among other elements in smaller quantities. Steel’s composition directly involves iron as its main component.

– Likely True: It is reasonable to assert that protective coatings on steel razor blades might react with gastric acid but may not prevent corrosion entirely. Many metals can react with strong acids, and while some coatings can provide a degree of protection against corrosion, no coating guarantees absolute resistance in such extreme conditions as found within the human stomach.

– True: Gastric acid typically has a pH range from 1.5 to 3.5, which is known for its strong acidity and potential to react with metals. This high level of acidity can lead to corrosion of various materials, including steel.

– Uncertain/Assumption: The duration and concentration of hydrochloric acid the razor blade is exposed to in the stomach are not specified in typical scenarios (e.g., accidental ingestion) or scientifically

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)