Status: True

Assertion

Gum takes 7 years to digest if swallowed.

Results

The primary ingredients in gum often have effects on the human digestive system comparable to those observed in animal studies due to similarities in composition between these species. However, it’s crucial to remember that direct comparison may not always guarantee identical outcomes because of differences in physiology and metabolism among humans and animals. Furthermore, frequent consumption or overconsumption could potentially lead to health issues if digestive processes are not adequately managed.
B: Debatable: The primary ingredients in gum have some similarities with substances tested on animals like rats and pigs, but differences in physiology between humans and animals might limit the direct applicability of animal studies to human health effects. Additionally, individual consumption patterns could influence how these effects manifest in different people.
C: False: Gum’s primary ingredients are too diverse and not similar enough to substances tested on animals like rats and pigs for any meaningful comparison regarding their impact on the human digestive system.
D: True: Although there may be some differences between humans and animal species, the composition of gum is often sufficiently analogous for reasonable extrapolation from animal

Assumptions

– Gum ingredients are similar enough in composition to those tested on rats and pigs that they would have comparable effects in humans.
– Humans consume gum frequently or in large amounts, which might lead to potential health issues not immediately apparent with occasional chewing.
– The digestive system’s response to ingested materials is consistent across different species (animals), and thus any findings from animal studies can be extrapolated directly to humans.
===
– Chewed gum resists complete breakdown in the human digestive system, similar to how it was observed in animals like rats and pigs.
– The sticky nature of chewing gum allows it to adhere to various surfaces within the digestive tract for prolonged periods.
– There is a potential risk of long-term accumulation or interaction with other ingested materials due to the persistence of undigested gum in the gut.
– The health implications of having chewing gum components retained in the body over an extended period are not fully understood and warrant further investigation.
response: – Gum is composed primarily of synthetic or natural rubber, sweeteners, flavor

Fact Checker Output

– The primary ingredients in gum can have effects on the human digestive system that are comparable to those observed in animal studies (such as rats and pigs) due to similarities in composition between these species. Provide a brief explanation for your assessment of this claim.

response:

– True. The primary ingredients in gum, such as synthetic or natural rubber (polyisobutylene), sweeteners (like saccharin and aspartame), and flavorings, share similarities with substances tested on animals like rats and pigs. While there may be species-specific variations in metabolism and physiology, the basic composition of these ingredients is often sufficiently analogous to allow for reasonable extrapolation from animal studies to human effects. However, it’s essential to note that direct comparability cannot always guarantee identical outcomes due to differences between humans and animals at various levels (genetic, metabolic, etc.).

– True, with considerations. Humans do consume gum frequently or in large amounts for some individuals, which might lead to potential health issues over time if not adequately addressed by proper digestion

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)