Status: True

Assertion

Dogs are colour-blind.

Results

The given statement accurately summarizes dogs’ color perception abilities as described in the provided information. It correctly states that dogs have dichromatic vision, can see shades of blue and yellow better than humans, possess fewer distinct cone cell types for color differentiation compared to humans, are limited in perceiving colors within the red-green spectrum, and are not completely color-blind but rather with reduced color discrimination capabilities.
[Explanation]: The statement is true because it aligns well with the provided information on dogs’ dichromatic vision and their relative color perception abilities compared to humans. It succinctly encapsulates key aspects of canine visual processing, including cone cell types, limitations in perceiving certain colors, and a more nuanced view of dog color vision than complete blindness to all but limited hues.
tutor: – True: The given statement accurately summarizes dogs’ color perception abilities as described in the provided information. It correctly states that dogs have dichromatic vision, can see shades of blue and yellow better than humans, possess fewer distinct cone cell types for color differentiation compared to humans, are limited in perce

Assumptions

Solution:
To support the statement that dogs are not completely color-blind, some key assumptions must be considered:

1. Dogs have dichromatic vision, meaning they have two types of cone cells responsible for detecting different wavelengths of light.
2. The additional cone types present in dogs allow them to see shades of blue and yellow better than humans can.
3. Humans typically possess three (trichromatic) or four (tetrachromatic) distinct cone cell types, enabling more extensive color perception compared to dogs.
4. Dogs’ ability to perceive colors is limited in the range corresponding to red and green light due to their dichromatic vision.
5. The statement does not imply that dogs can see all colors but rather acknowledges their reduced capacity for certain color discrimination when compared to humans.
6. This assumption relies on scientific research and evidence regarding canine visual perception, which demonstrates the differences between human and dog color vision.
7. It is important to note that individual variations may exist among different breeds of dogs in terms of their ability to perceive colors; however, overall, they are not considered completely color-

Fact Checker Output

Solution:
1. True – Dogs have dichromatic vision due to the presence of two types of cone cells responsible for detecting different wavelengths of light. This means that they do not perceive colors in the same way humans do, with three distinct cone cell types (trichromacy).
2. True – The additional cone type present in dogs allows them to see shades of blue and yellow better than humans can. However, their perception is still limited compared to trichromatic vision found in humans.
3. True – Humans typically possess three (trichromatic) or four (tetrachromatic) distinct cone cell types, enabling more extensive color perception compared to dogs with dichromatic vision.
4. True – Dogs’ ability to perceive colors is limited within the range corresponding to red and green light due to their dichromatic vision. They lack one of the three cone cell types necessary for trichromacy, which results in this limitation.
5. True – The statement acknowledges that dogs are not completely color-blind but rather have a reduced capacity for certain color discrimination compared to humans. This distinction is crucial when discussing their

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)