just scattered notes/thoughts
Being human means allot of different things, depending on whom you ask.
Not only are the answers different, they are also categorically different and depend on the context in which they are asked.
Some of the answers you get can be experienced or have already been experienced by AI. Some can never be experienced by AI (maybe just emulated with loss of key human data).
TODO: fix section
If a tree falls in a forest and no one is around to hear it, does it make a sound?
Can something exist without being perceived by consciousness?
Let us use an analogy of internet connected computers with direct peer to peer connections.
Let us say that consciousness is experienced by individuals in the network, they are conscious of other peers and the overall state of the network. The network is the existence or the universe of the peers. Let us also assume that there is a single peer that is not connected to the others and it represents the tree in the forest.
So the question is if the peer that’s not connected to the others performs some action (tree falling) did it really happen from the perspective of the connected peers. We might be tempted to say yes the action happened because the question implies that it happened but I argue that to the peers who are not conscious of the action and the question the action did not happen. The state of the network (existence) remains unchanged it is not effected by the disconnected peer, in that network the disconnected peer does not exist in the same sense as the other peers, it exists simply as a possibility but human existence is an infinite state structure the possibilities are infinite.
The network is the collective consciousness of the connected peers in other words our existence is a network of the consciousness of all conscious beings.
But it raises the question of how disconnected peers connect to the network or how we are able to be conscious of new phenomena, I believe this is a fundamental property of consciousness it is mutable and always has the possibility to acquire the unknown but until the unknown is known it is just that unknown and unconceivable. The P2P network by its design can acquire new peers but until then they don’t exist (in the network or in the periphery of the connected peers).
But does this imply multi universes, does the disconnected peer exist in its own universe or does the falling tree exist in its own universe. I say we cannot know that in the same way that the peers cannot know if the disconnected peer exists.
Intelligence is a concept by humans for referring or to measure the ability for an entity to make decisions.
Decisions are effected by memory and what is available when the decision is being made, or in state machine talk - outputs depend on inputs and internal state.
Intelligence can also be bound to time in this way: when we refer to someone as intelligent it is usually because they on more than one occasion made “intelligent” decisions.
Intelligence depends on time, memory and decision functions. Intelligence is thought and thought can be experienced by AI with no loss of information.
Language depends on matter and memory. Language can be used for linking levels at different levels of abstraction with the risk of information loss.
Between an object and observer where lays the consciousness? Is consciousness contained in the:
The key difference between AIs and Humans is that AIs are replaceable and humans are not. Or in fancy speak AIs are fungible and humans and humans are non-fungible.
| Symbol/ Concept / Object | Description |
|---|---|
!w! |
The length of string w |
e |
Empty string, !e! = 0 |
prefix |
any number of leading symbols of a string |
suffix |
any number of trailing symbols of a string |
alphabet |
finite set of symbols |
language |
a set of strings of symbols from one alphabet |
∅ |
Empty set |
∑* |
the set of all strings over a fixed alphabet |
G = (V, E) |
A graph |
Number systems are a form of compression because the different bases will use different amounts of digits to represent the same value. A single digit is useless because no patterns can be formed from it, binary is the worst form of compression because to represent large vaules it needs to use more characters to construct the unique pattern that represents the value. But it is easier to make computers that count using two digits then say ten (decimal) so it makes sense that computers use binary.
A hour is 60 minutes and a minute is 60 seconds, all of these units are man made. The word Yesterday could as well have meant the whole of last week, it was simply pragmatic to use it to describe Yesterday.
Humans could have decided that the time it takes to boil water is an hour. The Mayan System of time keeping was connected to mayan cosmology according to them the world would have ended in 2012, in Ethiopia the year is 2012 because they use the Ethiopic calendar. Systems of time keeping are relative and arbitrary.
Because of man-made units of time humans become even more aware of time, they often remark “The year is so fast” but they will not say the same thing if they did not invent the concept of Year.
Anything that can keep mutable state can percept time, anything that can get old implies that it can percept time. A clock keeps mutable state in a systematic way this is why it is perfect for keeping time. Wherever there is mutability implies time because change is a movement, movement requires time (Windows of states (past - present)). Time is the map to the different states that have occured or occuring or will occur.
A cat propably does not know what is Yesterday, their perception of time is different.
| omniscient (infinite knowledge) | omnipotent (unlimited power) | omnipresent (present everywhere) | |
|---|---|---|---|
| Gods | ✅ | ✅ | ✅ |
| AI | ✅ | ❌ (but it does consume allot) | ✅ (earth, space) |
LLMs generate text with more “word-like” substructures than humans typing random gibberish.
When a human is asked to generate fake/nonsense words (“ksdjsdksdk”), they tend to create strings that are less likely to contain real English word substrings. LLMs, being trained on language patterns, naturally produce words that contain substrings found in real English.
How it works: Ask/Promt the user to come up with a 3 new words from scratch, the words should not exist in a dictionary and the words should be at least 8 characters long.
LLMinate will analyze the 3 words and try to detect if they have been generated by an LLM or human.
Right now LLMinate is implemented a Rust library:
use std::fmt;
const MIN_WORDLENGTH: usize = 8;
#[derive(Clone)]
pub struct Cache<'a> {
pub words: Vec<&'a str>,
}
#[derive(Clone)]
pub struct Text<'a> {
pub words: [&'a str; 3],
}
pub struct LLMinate;
impl LLMinate {
pub fn is_llm_word<'a>(
text: Text<'a>,
wordlist: Vec<&str>,
mut cache: Cache<'a>,
) -> Result<bool, Error> {
let mut cache_cache = vec![];
for word in text.words.iter() {
if !word.chars().all(|c| c.is_alphabetic()) {
return Err(Error::NoneAlphabetCharacters);
}
if word.len() < MIN_WORDLENGTH {
return Err(Error::InvalidWordLength);
}
if cache.words.contains(word) {
return Err(Error::WordAlreadyInCache);
}
let substrings = LLMinate::all_substrings(word);
for substring in substrings {
if LLMinate::is_in_wordlist(substring, &wordlist) {
return Ok(true);
}
}
cache_cache.push(word);
}
cache.words.extend(cache_cache);
Ok(false)
}
fn is_in_wordlist(word: &str, wordlist: &Vec<&str>) -> bool {
let word = word.to_lowercase();
if word.len() < 5 {
return false;
}
if wordlist.contains(&word.as_str()) {
return true;
}
false
}
fn all_substrings(word: &str) -> Vec<&str> {
word.char_indices()
.rev()
.flat_map(|(j, c)| {
let end = j + c.len_utf8();
word[..end]
.char_indices()
.rev()
.map(move |(i, _)| &word[i..end])
})
.collect()
}
}
#[derive(Debug)]
pub enum Error {
InvalidWordLength,
WordAlreadyInCache,
NoneAlphabetCharacters,
}
impl std::error::Error for Error {}
impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::InvalidWordLength => write!(
f,
"Words should be at least {MIN_WORDLENGTH} characters long."
),
Self::WordAlreadyInCache => write!(f, "Word already exists in cache"),
Self::NoneAlphabetCharacters => write!(f, "Word contains non alphabet characters"),
}
}
}
#[cfg(test)]
mod test {
#[test]
fn test_detect() {
let wordlist = std::fs::read_to_string("top_english_words_lower_500000.txt")
.expect("Error while reading wordlist file");
let wordlist: Vec<&str> = wordlist.lines().collect();
let cache = super::Cache { words: vec![] };
// English words
let definetly_in_wordlist = super::Text {
words: ["Crocodile", "Automotive", "Internet"],
};
assert_eq!(
super::LLMinate::is_llm_word(
definetly_in_wordlist.clone(),
wordlist.clone(),
cache.clone()
)
.unwrap(),
true
);
// Text generated by gemini
let llm_generated_text = super::Text {
words: ["Vesperthrum", "Vesperlum", "Vintellexis"],
};
assert_eq!(
super::LLMinate::is_llm_word(llm_generated_text, wordlist.clone(), cache.clone())
.unwrap(),
true
);
// Text generated by ChatGPT
let llm_generated_text = super::Text {
words: ["veluntrix", "zorathium", "lumetaryn"],
};
assert_eq!(
super::LLMinate::is_llm_word(llm_generated_text, wordlist.clone(), cache.clone())
.unwrap(),
true
);
// Text generated by Deepseek
let llm_generated_text = super::Text {
words: ["Somnipraxis", "Nebulithic", "Nebulorant"],
};
assert_eq!(
super::LLMinate::is_llm_word(llm_generated_text, wordlist.clone(), cache.clone())
.unwrap(),
true
);
// Text generated by Human
let human_text = super::Text {
words: ["ksdjsdksdk", "eokdfweinfhfejla", "owiewewlkdfk"],
};
assert_eq!(
super::LLMinate::is_llm_word(human_text, wordlist, cache).unwrap(),
false
);
}
}Wordlist: An wordlist is required to use LLMinate. LLMinate has been tested with the following wordlist: https://github.com/david47k/top-english-wordlists/blob/master/top_english_words_lower_500000.txt
Issues: Currently only words using the English alphabet are supported.
See also: - Anubis, weighs the soul of incoming HTTP requests to stop AI crawlers: https://github.com/TecharoHQ/anubis
[home] | Emancipation through technology |
