Status: True

Assertion

Cracking your knuckles causes arthritis.

Reasoning

The statement aligns with the provided information that most studies do not conclusively link habitual knuckle cracking to long-term negative effects on joint health, arthritis development, or permanent discomfort. However, there is acknowledgment of potential harm over a lifetime and possible temporary discomfort following the action.

Support: 1. True: While there have been concerns about habitual knuckle cracking possibly causing long-term negative effects on joint health, current evidence does not conclusively prove this. Some research suggests that it could potentially lead to harm over time if done consistently.

2. True: Scientific research has looked into the connection between frequent knuckle cracking and arthritis later in life but results have been inconclusive with no definitive evidence linking them.

3. True: The temporary discomfort felt after cracking one’s knuckles could be due to stretching or straining of nearby ligaments and tendons, as a result of the sudden release of built-up gases in the joint capsule during the action.

4. True: This aligns with the explanation given for temporary discomfort after cracking

Assumptions

<|assistant|> 1. Knuckle-cracking does not have proven long-term negative effects on joint health.

2. Scientific research has been conducted to investigate any potential links between knuckle cracking and arthritis.

3. Temporary discomfort from knuckle cracking is a possible, but short-lived effect.

4. Discomfort experienced after cracking one’s knuckles may be due to stretching of ligaments around the joints.

5. The majority of studies do not support a direct causal relationship between habitual knuckle cracking and arthritis development later in life.

6. Moderation is advised for general wellness, regardless of knuckle-cracking habits.

7. Individual experiences with discomfort from knuckle cracking may vary but are generally short-term without long-lasting consequences.

Fact Checker Output

Support: 1. True – While there have been concerns and studies related to knuckle-cracking, current evidence does not conclusively prove that it causes long-term negative effects on joint health. However, some research suggests potential for harm over a lifetime of habitual cracking.

2. True – Scientific research has investigated the relationship between knuckle cracking and arthritis, but findings have been inconclusive with no definitive evidence linking frequent knuckle-cracking to arthritis development later in life.

3. True – Discomfort after knuckle cracking is typically temporary and may be related to the stretching of ligaments around joints due to sudden changes in joint pressure or position, but it doesn’t necessarily imply long-term harm.

4. True – It is possible that discomfort experienced after cracking one’s knuckles could result from slight stretching or straining of surrounding ligaments and tendons because of the rapid release of built-up gases in the joint capsule during the action.

5. Mostly true – The majority of studies do not establish a direct, causal relationship between habitual

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
from wordpress_helper import create_wordpress_post  # Import WordPress helper functions
import html

# Load environment variables from .env file
load_dotenv()

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):
    llm = OpenAI(temperature=0.7, model=os.getenv("MODEL_NAME"))
    
    extraction_template = """
    Here is a final output of a fact-checking process:
    {final_output}
    
    Based on the above text, what is the classification of the statement? Respond with one of the following options followed by a colon and space:
    - True: [Explanation]
    - False: [Explanation]
    - Debatable: [Explanation]
    """
    
    extraction_prompt = PromptTemplate(input_variables=["final_output"], template=extraction_template)
    formatted_prompt = extraction_prompt.format_prompt(final_output=final_output).text
    extraction_output = llm.invoke(formatted_prompt).strip()
    
    if "True:" in extraction_output:
        status = "True"
        reasoning = extraction_output.split("True:", 1)[1].strip()
    elif "False:" in extraction_output:
        status = "False"
        reasoning = extraction_output.split("False:", 1)[1].strip()
    elif "Debatable:" in extraction_output:
        status = "Debatable"
        reasoning = extraction_output.split("Debatable:", 1)[1].strip()
    else:
        status = "Unknown"
        reasoning = extraction_output
    
    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)
    
    # Print the final status and reasoning
    print(final_output)
    print(f"Status: {status}")
    print(f"Reasoning: {reasoning}")

    # 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
            reasoning=reasoning,
            model=os.getenv("MODEL_NAME")
        )
        print("Record inserted into MongoDB successfully.")
    except Exception as e:
        print(f"Failed to insert record into MongoDB: {e}")
    
    # 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>Reasoning</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)