Status: True

Assertion

Dogs are colour-blind.

Results

The assumption that dogs have only two types of cone cells (blue-sensitive and grayscale) aligns with scientific findings on canine vision. Dogs’ dichromatic color perception is a well-established concept in the field of comparative animal physiology, indicating they perceive colors differently from humans who have trichromatic vision due to three types of cone cells sensitive to different wavelengths (red, green, and blue). This limitation affects their ability to distinguish between certain color hues that humans can differentiate. However, it’s important to note the variations among dog breeds regarding specific visual capabilities.

The statement “B: True” acknowledges this assumption as true based on a comprehensive understanding of animal vision and physiological differences in cone cells between dogs and humans. It’s essential to approach such statements with an awareness that there could be individual variations among dog breeds, but overall scientific evidence supports the claim about dogs having dichromatic color perception compared to the trichromatic vision of humans.

Assumptions

* Dogs have only two types of cone cells (blue-sensitive and grayscale), which limits their color perception compared to humans.
* Most dog breeds do not possess trichromatic vision, leading them to see fewer colors than humans.
* The ability to distinguish between certain color combinations is limited in dogs due to the lack of specific cone cell types for those hues.
* Color differentiation capabilities can vary among dog breeds, with some having a broader range of perceived colors but still not matching human vision.
* It’s essential to consider that while dogs may not see as many colors as humans do, they have adapted well to their environment using the available color spectrum in their perception.

Supporting these assumptions requires an understanding of canine physiology and visual systems, along with comparisons between human and dog vision capabilities. However, it’s important to remember that while dogs may not see colors like humans do, they are still highly adaptive creatures capable of thriving in their environment.

Here is a statement:
A. True
B. False

Solution: The corrected statement would be “Dogs have a different range and spectrum of color per

Fact Checker Output

Supporting these assumptions requires an understanding of canine physiology and visual systems, along with comparisons between human and dog vision capabilities. However, it’s important to remember that while dogs may not see colors in the same way humans do, they have adapted well to their environment using the available color spectrum in their perception.

Given this information, the statement “A: True” can be considered true, as all of these assumptions are supported by scientific evidence and understanding of animal vision, particularly in dogs compared to humans. However, it’s essential to approach these statements with an acknowledgment that while they are generally accurate, there might still exist individual variations among dog breeds regarding their color perception abilities.

Assumption:
* Dogs have only two types of cone cells (blue-sensitive and grayscale), which limits their color perception compared to humans.

This assumption is true based on scientific research indicating that most dogs do not possess trichromatic vision, like humans. Instead, they typically have dichromatic vision with one type of photoreceptor sensitive to blue light (similar to a human’ayer) and another to grayscale wavelengths. This difference in cone cell types significantly impact

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)