Status: True

Assertion

Gum takes 7 years to digest if swallowed.

Results

Gum primarily consists of synthetic rubber (latex) and sweeteners like sugar alcohols, making it difficult for the human digestive system to break them down. Chewing gum stimulates peristalsis, which can help with the movement of food through the digestive tract, although this may not significantly affect how long ingested gum remains in the stomach. The statement that chewing gum does not completely prevent it from remaining longer than other consumed substances is true based on these factors.

– False: This option would imply that either one or more aspects of the statement are incorrect, but according to the provided information, all parts of the statement can be considered true in relation to how gum behaves within the human body and digestive system.

– Debatable: Since there could be varying individual reactions to chewing gum that might affect its presence in the stomach (e.g., differences in peristalsis or specific intolerances), some aspects of the statement may be seen as subject to debate. However, based on general scientific understanding, most components of the statement can still be considered true for an average individual without specific g

Assumptions

Some assumptions that could be made to support the claim that gum stays in our digestive system for 7 years are:

1. The body cannot break down or process chewed gum due to its composition, primarily consisting of synthetic rubber and sweeteners.
2. Gum pieces pass through the digestive tract without being broken down into smaller particles that can be absorbed by the body.
3. Chewing gum does not stimulate peristalsis (the movement of food through the digestive system) to some degree, allowing it to remain in the stomach for an extended period.
4. The human body lacks mechanisms or enzymes that can break down and eliminate chewed gum effectively over time.
5. There is no evidence from medical imaging or research studies to support the claim that ingested gum will eventually be expelled from the digestive system within a reasonable timeframe (e.g., several weeks, months).
6. Chewing sugar-free gum does not have any impact on its ability to remain in the digestive system for an extended period compared to regular chewed gum.

It’s essential to note

Fact Checker Output

<|assistant|> 1. True – Gum primarily consists of synthetic rubber (latex) and sweeteners like sugar alcohols such as xylitol or aspartame. These substances are not easily broken down by the human digestive system, contributing to gum staying in the body longer than food.

2. True – Gum pieces generally do not break down into smaller particles that can be absorbed because of their composition (synthetic rubber and sweeteners). Instead, they tend to pass through the digestive tract mostly intact. However, it’s essential to note that some small amounts may still break down due to mechanical actions in the stomach or intestines.

3. False – Chewing gum does stimulate peristalsis. The act of chewing increases muscle contractions and movement in the digestive tract, helping food move through it efficiently. However, this effect may not be significant enough to prevent ingested gum from remaining in the stomach for an extended period.

4. True – The human body lacks specific enzymes or mechanisms that can break down synthetic rubber and sweeteners found in che

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)