Status: True

Assertion

Yawning is contagious.

Reasoning

The observation of yawning in one individual triggering similar behavior in others has been documented through various empirical studies, indicating that contagious yawning can occur among humans. These studies have shown a higher likelihood of yawn-induced responses when people are engaged or connected to the initial yawner, supporting its social influence aspect.

– True: Contagious yawning is believed to be linked to empathy and social bonding due to evidence suggesting that it occurs more frequently among individuals who have a strong emotional connection (e.g., family members), indicating an emotional component to contagious yawning. This implies there are measurable responses involved when people yawn in response to others, which aligns with the assumption of social or emotional involvement.

– True: Yawning is not exclusive to humans; it has been observed among many species, including dogs and chimpanzees. These cross-species observations support a possible evolutionary basis for contagious yawning that extends beyond human behavior alone, suggesting an inherent biological or social function of this phenomenon in various animals.

– True: While the precise mechanisms behind contag

Assumptions

Assumptions supporting the statement “Yawning can be contagious among humans”:

– The observation of yawning in one individual triggering similar behavior in others is based on empirical studies demonstrating this phenomenon.
– There are measurable social or emotional responses involved when individuals yawn, suggesting a potential link to empathy and social bonding.
– Yawning among humans can be considered comparable to yawning observed in other species, such as dogs and chimpanzees, implying an evolutionary aspect of contagious yawning that transcends species boundaries.
– The underlying mechanisms behind contagious yawning are not fully understood but may involve mirror neurons or some form of subconscious mimicry process.
– Current research acknowledges the potential for further investigation to delve into the nuances and implications of contagious yawning on human behavior and social interactions.

Fact Checker Output

<|assistant|> – True: The observation of yawning in one individual triggering similar behavior in others has been documented through various empirical studies, indicating that contagious yawning can occur among humans. These studies have shown a higher likelihood of yawn-induced responses when people are engaged or connected to the initial yawner, supporting its social influence aspect.

– True: Contagious yawning is believed to be linked to empathy and social bonding due to evidence suggesting that it occurs more frequently among individuals who have a strong emotional connection (e.g., family members), indicating an emotional component to contagious yawning. This implies there are measurable responses involved when people yawn in response to others, which aligns with the assumption of social or emotional involvement.

– True: Yawning is not exclusive to humans; it has been observed among many species, including dogs and chimpanzees. These cross-species observations support a possible evolutionary basis for contagious yawning that extends beyond human behavior alone, suggesting an inherent biological or social function of this phenomenon in various animals.

– True: While the precise mechanisms behind contagious

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=__file__,
            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)