Status: Debatable

Assertion

Bananas are berries, but strawberries are not.

Results

While bananas do indeed develop from an ovary of a single flower, their classification as true berries can be debated because they contain multiple seeds (ovules) within what is considered the fruit structure. The term “true berry” typically refers to fruits like grapes or tomatoes that have one seed per locule (chamber), while bananas technically fit the broader definition of a berry, making their classification somewhat ambiguous without further context.

– Berries are always sweet and edible: False. The taste and edibility of berries can vary greatly among species. While some common types like grapes or blueberries may be commonly perceived as “sweet” or “edible,” there are numerous other berry species that might not fit this description, such as certain varieties of brambles (e.g., blackberry) and nightshades (e.g., tomatoes), which can have different tastes ranging from sour to bitter.

– Berries do not contain seeds: False. In botanical terms, berries are defined as fruits containing one or more seeds enclosed within the ovary

Assumptions

<|assistant|> – Botanical definitions of fruit: The botanical definition of a fruit is any seed-bearing structure formed from the ovary of a flower, while an aggregate fruit is derived from multiple ovaries within a single flower receptacle.
– True berries are defined as fruits produced by one flower with one ovary containing its seeds.
– Bananas fall into the category of true berries according to botanical definitions because they develop from one flower that contains an ovary and seeds.
– Strawberries, although commonly thought of as berries, are not classified as true berries due to their unique structure: They have multiple ovaries within a single enlarged receptacle rather than being derived from just one flower’s ovary with its seed(s).
– The classification and understanding of fruits can be complex due to variations in definitions based on different perspectives, such as botanical vs culinary.
– Culinary classifications of fruit often differ from the botanical definition. For example, strawberries are commonly referred to as berries in culinary contexts despite not fitting this classification according to botany.
– To avoid misconceptions when

Fact Checker Output

Response:
– Botanical definitions of fruit: True. The botanical definition describes a fruit as any seed-bearing structure formed from the ovary of a flower and specifies what constitutes an aggregate fruit. This statement accurately reflects the scientific classification of fruits.

– True berries are defined as fruits produced by one flower with one ovary containing its seeds: True. In botanical terms, true berries indeed have their seeds enclosed within a single ovary that develops from just one flower. This definition helps distinguish true berries from other types of fruit structures.

– Bananas fall into the category of true berries according to botanical definitions because they develop from one flower that contains an ovary and seeds: False. Although bananas do grow from a single flower with one ovary, in their mature form, they contain multiple seeds (technically called “ovules”) within what is considered the fruit structure. However, technically speaking, this characteristic makes them more accurately classified as berries in botanical terms since they still develop from an ovary of a single flower. This statement could be misleading without context because it oversimplifies banana’s

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)