Status: True

Assertion

The human nose can detect over 1 trillion scents.

Results

All four statements provided about human olfaction are accurate, based on our current understanding of the human sense of smell. The first statement is true as humans have around 400 types of olfactory receptors for detecting various odorants. The second statement is also correct since different variations in intensity and quality can lead to distinct perceptions of scents, even if they share common molecular structures. The third statement aligns with our ability to sense minute changes in the composition of odorant molecules, resulting in a vast range of perceived smells. Lastly, while mathematical models like Estimate 10,240 offer an estimation rather than precise calculations, this statement can be considered mostly true as they reflect ongoing research and attempts to quantify olfactory capacity.

– True: The human olfactory system consists of around 400 different types of receptors that detect various odorants; this diversity allows for the perception of a wide range of scents. Variations in intensity, such as stronger or weaker smells, and differences in quality, like fruity versus floral notes, contribute to our ability to distinguish between seemingly similar compounds

Assumptions

<|assistant|> Assumptions supporting the statement about humans potentially perceiving around 1 trillion different scents:

– The human olfactory system has an extensive range of receptor proteins that can bind and identify diverse chemical compounds in odors.
– Each distinct smell contains subtle variations, including differences in intensity or quality (e.g., fruity versus floral notes).
– These variations are perceptible to humans as different scents even when they share a common underlying molecular structure.
– The human nose has the capability of detecting and distinguishing between minute changes in odorant composition, leading to an infinite combinatorial possibility of unique smells.
– Current mathematical models used to estimate olfactory capacity are accurate representations of our sensory capabilities.
– Individual differences among humans do not significantly limit their collective ability to perceive a vast array of scents; the upper limit is more reflective of average human experience rather than exceptional cases.
– The concept of “trillions” serves as an approximation, acknowledging that precise counting may be impossible due to complexities in odor perception and potential for new discoveries.

Fact Checker Output

Tutor: 1. True – The human olfactory system has around 400 different types of olfactory receptors that can bind to various molecular structures found in odorants, allowing for the detection and identification of a wide range of smells. This diversity contributes significantly to our ability to perceive many distinct scents.

2. True – Different variations in intensity (e.g., stronger or weaker) and quality (e.g., fruity versus floral notes) exist within the same chemical compounds, leading humans to perceive them as different smells even if they share a common molecular structure. This is because our sense of smell is highly sensitive to subtle changes in odorants.

3. True – The human olfactory system can detect and distinguish between minute changes in the composition of odorant molecules, which contributes to the perception of an infinite number of unique scents. Our noses are capable of identifying differences even at a very low level of variation.

4. Mostly true – Current mathematical models used to estimate olfactory capacity, such as Estimate 10,240 (based on the presence of approximately

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)