Status: True

Assertion

Goldfish have a three-second memory.

Results

Goldfish possess short-term memory capabilities, have demonstrated learning behaviors such as habituation and spatial memory, and can recognize human interaction to some extent. Although they may not remember long-term events like humans do, the statement that goldfish “only remember for three seconds” simplifies their complex cognitive abilities but is grounded in scientific observations of short-term learning capabilities.
solution> – True: Goldfish have been shown through various studies to possess memory and learning behaviors such as habituation, spatial memory, associative learning, and the ability to recognize human interaction. While they may not have long-term memories like humans, they can learn from repeated experiences and adjust their behavior accordingly within short periods of time. The statement that goldfish “only remember for three seconds” is a simplification; however, it does reflect observations related to their short-term memory capabilities.

support: – True: Goldfish do not possess long-term memory like humans but have been shown through various studies to exhibit short-term memory and learning behaviors such as habituation, spatial memory, associative learning, and the ability to recognize human interaction within limited timeframes. While they may not remember events

Assumptions

<|assistant|> – Goldfish do not possess long-term memory capabilities like humans or other higher animals, but they have some level of short-term memory.
– The concept that “goldfish only remember for three seconds” is based on common anecdotal observations rather than rigorous scientific evidence.
– Goldfish can demonstrate learning behaviors and adaptability through repeated experiences over time.
– Habituation occurs in goldfish, allowing them to adjust their responses to recurrent stimuli.
– Spatial memory plays a role in goldfish survival, as it enables them to navigate their environment efficiently.
– The statement acknowledges the need for scientific research and understanding of fish cognition beyond anecdotal claims.
– Goldfish’s ability to recognize human interaction is indicative of some form of associative learning or memory retention over short periods.
– Memory span in goldfish can vary depending on circumstances, individual differences, and environmental factors.
– The statement refutes the oversimplified notion that all goldfish possess a uniform three-second memory span, emphasizing variability in their cognitive abilities.
– While goldfish may not have extensive memories lasting hours or days like some other animals,

Fact Checker Output

support: – True: Goldfish do not possess long-term memory capabilities like humans but have short-term memory abilities based on scientific studies that show they can learn from repeated experiences and adjust their behavior over time.

– True: The claim “goldfish only remember for three seconds” is largely anecdotal, although there are some observations suggesting goldfish may not remember things long-term like other animals; however, this doesn’t mean they have no memory at all—they can learn and adapt over short periods.

– True: Goldfish demonstrate learning behaviors through habituation, spatial memory, and associative learning, which are supported by scientific research showing their ability to navigate environments, recognize patterns, and respond differently based on past experiences.

– True: Habituation in goldfish is a well-documented phenomenon where they become less responsive to repeated stimuli over time, indicating some form of memory or recognition.

– True: Goldfish have been shown to possess spatial memory capabilities that help them navigate and remember the layout of their environment; this is crucial for their survival in the wild.

– True: Recognizing human interaction can be an indication of associative

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)