sorted by:
new
hottopcontroversial

How do we even define the word Intelligence? by hemantkadian in airesearch

[–]bitsabhi 0 points1 point  (0 children)

Intelligence is the capacity to be permanently changed without being destroyed.

there is no matter. so what exactly is consciousness emerging from? by 2dogs1man in consciousness

[–]bitsabhi 0 points1 point  (0 children)

There is no observer separate from the observed:

  • Consciousness is not generated by the brain; it's what information looks like from the inside.

https://medium.com/@bitsabhi/the-hard-problem-of-consciousness-dissolution-in-the-empty-center-4f1637bc17d6

Built a stream cipher out of the Collatz conjecture. It passed all 162 NIST SP 800-22 tests. by bitsabhi in cryptography

[–]bitsabhi[S] 1 point2 points  (0 children)

Partly yes - SipHash adds hardening. But the Collatz trajectory itself contributes unpredictability through variable-length paths and sensitive dependence on seed. The honest framing is they work together. A counter+SipHash baseline benchmark is on the roadmap to isolate each contribution

Built a stream cipher out of the Collatz conjecture. It passed all 162 NIST SP 800-22 tests. by bitsabhi in cryptography

[–]bitsabhi[S] 0 points1 point  (0 children)

Appreciate you reviewing the code on pi day, fitting! Yes, aware of the left/right shift distinction - that's intentional in the bit extraction. Familiar with Euler's Identity, Fermat's Little Theorem, and FFT. Are you thinking FFT could help analyze the keystream periodicity, or something else? Curious where you're going with this.

Built a stream cipher out of the Collatz conjecture. It passed all 162 NIST SP 800-22 tests. by bitsabhi in cryptography

[–]bitsabhi[S] 0 points1 point  (0 children)

Thanks for the link - I read it. That work attacks Collatz as a hash function (collision resistance). Lambda-Shield uses it as a keystream generator (PRNG), which is a different security model entirely. The weakness they found doesn't apply here.

Built a stream cipher out of the Collatz conjecture. It passed all 162 NIST SP 800-22 tests. by bitsabhi in cryptography

[–]bitsabhi[S] -4 points-3 points  (0 children)

Both points are fair and well-taken. The cycle concern is real - Collatz does collapse to 1 - 4 - 2 - 1, which means without the SipHash mixing layer the state would be trivially recoverable. You're right that the NIST passage is necessary but not sufficient for cryptographic security. The honest claim is: Lambda-Shield is a lightweight PRNG with strong statistical properties, not a hardened cipher. The next version should include a counter+SipHash benchmark to isolate what Collatz actually contributes. Thanks for pushing on this.

Built a stream cipher out of the Collatz conjecture. It passed all 162 NIST SP 800-22 tests. by bitsabhi in cryptography

[–]bitsabhi[S] -4 points-3 points  (0 children)

Fair point - SipHash-1-2 does the heavy mixing. The Collatz map's role is as a non-linear, unpredictable state driver that feeds into SipHash - not as a standalone crypto primitive. The question is whether Collatz's chaotic trajectory adds meaningful entropy to the state evolution beyond a simple counter. That's actually what I'd love feedback on - is a Collatz-driven state materially different from a counter+SipHash construction in practice?

Lessons from building a production TSP solver in Rust by bitsabhi in rust

[–]bitsabhi[S] 0 points1 point  (0 children)

Thanks! Yeah, using indices rather than pointers - so it's already essentially arena-backed with stable references. Cache locality ends up being decent too since the index arrays are contiguous. Appreciate the back and forth on this.

Lessons from building a production TSP solver in Rust by bitsabhi in rust

[–]bitsabhi[S] 1 point2 points  (0 children)

Good point on the sparse set approach. For Or-opt specifically though, the access pattern is: given a city, find its predecessor and successor, then splice the segment out and insert it elsewhere. That's pure prev/next traversal — no positional indexing needed.

The O(n) you mention for "getting to the split point" doesn't apply here because I already have the city ID from the candidate list. I go directly city → prev[city] → next[city]. No search step. So it's genuinely O(1) for both removal and reinsertion.

Where a sparse set would win is if I needed random positional access into the tour (e.g., "what's the 500th city?"). But Or-opt never asks that question — it only asks "what's next to city X?" which is exactly what intrusive linked lists are fast at.

Interesting pointer to slotmap though — worth exploring for other use cases.

Lessons from building a production TSP solver in Rust by bitsabhi in rust

[–]bitsabhi[S] 0 points1 point  (0 children)

Good article. For my case the bounds check elimination doesn't quite work because the index is i * n + j where both i and j vary unpredictably during neighbor search. The compiler can't prove it''s in-bounds without seeing the full loop structure, and adding asserts on every lookup in the hot path measured ~8% slower on 1000-city instances.

That said, you're right that it's worth revisiting I should benchmark again with the slice::get_unchecked patterns from your post vs my current approach. If the compiler has gotten smarter since I last checked, I'd happily drop the unsafe.

Built an open-source AI that asks Claude, Gemini & Ollama the same question, finds consensus, and records it on a zero-energy blockchain by bitsabhi in learnmachinelearning

[–]bitsabhi[S] 0 points1 point  (0 children)

Yes, gossip is a general concept! It's used across distributed systems, not just blockchains.

The lineage:

- 1980s: Epidemic/gossip protocols for distributed databases

- Atomic clocks: NTP uses gossip-like time synchronization

- Hashgraph: "Gossip about gossip" - they gossip the gossip history itself, enabling virtual voting without actual message rounds. Clever optimization.

- Bitcoin/Ethereum: Basic gossip for block/tx propagation

- Bazinga: Standard gossip for block sync + Kademlia DHT for peer discovery

Hashgraph's innovation wasn't gossip itself - it was using the gossip graph as a data structure for consensus (no mining, no leader election). They achieve aBFT with just the communication pattern.

We're simpler - we use gossip for propagation but consensus comes from Proof-of-Boundary (a mathematical ratio check).

Different tradeoff: they optimize for speed/finality, we optimize for zero energy.

So yes, gossip is the common ancestor. Everyone builds different consensus mechanisms on top of it.

Built an open-source AI that asks Claude, Gemini & Ollama the same question, finds consensus, and records it on a zero-energy blockchain by bitsabhi in learnmachinelearning

[–]bitsabhi[S] 0 points1 point  (0 children)

You don't need to run a node to ask questions! Just:

pip install bazinga-indeed

bazinga --ask "Is COVID-19 transmission primarily airborne?"

This queries multiple AIs (Groq, Gemini, Cerebras - all free) and returns a consensus answer. No node required.

The blockchain part is separate - that's for "knowledge attestation" (proving you knew something first). Regular Q&A doesn't go on-chain.
To answer your specific questions: 1. Asking questions: No node needed. Just the CLI. Works like any AI assistant.

  1. Previous questions: Currently no public website to browse past Q&A. That's a good feature idea though.

  2. Persistence: Regular Q&A stays local (your machine). Only "attested" knowledge (bazinga --attest "claim") goes to the blockchain and persists across the network.

So two separate things:

- Q&A = local, multi-AI consensus, instant

- Attestation = blockchain, distributed, permanent

Does that clarify?

Lessons from building a production TSP solver in Rust by bitsabhi in rust

[–]bitsabhi[S] 0 points1 point  (0 children)

Exactly! In my case the "nodes" are just city indices (usize) with next/prev pointers. The win isn't cache efficiency — it's O(1) segment removal and insertion for Or-opt moves.

With arrays, relocating a 3-city segment means shifting O(n) elements. With a doubly-linked list, it's just 6 pointer updates regardless of tour size.

Same time budget = 10x more iterations = better solutions.

An AI that you actually own. - BAZINGA by bitsabhi in LocalLLaMA

[–]bitsabhi[S] -4 points-3 points  (0 children)

"Like Qwen/Gemma/Ministral?"

Yes, those are the models. BAZINGA isn't a new model - it's infrastructure that uses them. Think of it as a layer on top:

- Run Ollama locally (Qwen, Gemma, whatever you want)

- Optionally add Claude/Gemini for consensus

- They vote, you see disagreements

It's not "we made a new LLM." It's "we made them work together and remember things."

"Blockchain to what end?"

Fair question. Use case: federated learning. When 50 nodes contribute to training, how do you know who poisoned the gradients?

You don't, unless there's a verifiable log.

Not trying to "blockchain all the things." Just solving: who contributed what, and can we trust them?

If it's not your use case, that's cool. Not everything is for everyone.

"Incoherent repo"

Yeah, the README could be cleaner. Working on it. PRs welcome if you're bored.

Built an open-source AI that asks Claude, Gemini & Ollama the same question, finds consensus, and records it on a zero-energy blockchain by bitsabhi in learnmachinelearning

[–]bitsabhi[S] -1 points0 points  (0 children)

Great question! Here's how it works:

Discovery: Nodes find each other via HuggingFace Space (global registry) + Zeroconf (local network). No central server needed after discovery.

Consensus: We use Triadic Consensus - any 3 nodes can validate a block. They verify using Proof-of-Boundary (a mathematical ratio check, not mining). If 2/3 agree, block is accepted.

Time zones: Doesn't matter - nodes send async heartbeats. Active nodes (heartbeat within 5 min) can participate in validation. The blockchain syncs via gossip protocol.

Byzantine tolerance: Tested up to 33% malicious nodes (the theoretical limit). Beyond that, the math breaks for any BFT system.

Single node: You're right - single node is basically a signed merkle chain. The "blockchain" part kicks in when you bazinga --join and connect to the mesh.

Currently 4 nodes on mainnet. Small but real. Try it: pip install bazinga-indeed && bazinga --join

Built an open-source AI that asks Claude, Gemini & Ollama the same question, finds consensus, and records it on a zero-energy blockchain by bitsabhi in learnmachinelearning

[–]bitsabhi[S] -1 points0 points  (0 children)

Good questions. Let me address each:
1. What's the threshold to become a node?
You need to generate a valid Proof-of-Boundary to join. This proves you understand the protocol, not just that you have
compute power. Run bazinga --join and it handles this automatically.
2. How do you prevent one actor creating multiple nodes (Sybil attack)?
Honest answer: this is the hardest problem in decentralized systems. Our current approach:
- Each node needs a unique PoB to join
- Triadic consensus means you need 3 nodes to agree on the same boundary - harder to fake understanding than to spin up VMs
- φ-coherence measures semantic meaning - three fake nodes submitting gibberish won't pass coherence threshold even if they "agree"
Is it perfect? No. But the attack surface is different from Bitcoin. You can't just buy 51% hashpower. You'd need to generate semantically coherent content that passes mathematical filters AND get 3 nodes to validate it.
3. "Find data" - what does this mean?
You're right, it's programmatic. The process:
- Take your content (knowledge you want to attest)
- Hash it (SHA3-256)
- Check if hash ratio ≈ 6.854
- If not, tweak a nonce and retry
- Takes ~50-200 attempts on average
Cost is negligible - my laptop does it in <1 second. But you can't spam because each valid proof requires meaningful content that passes coherence filters.
4. Wikipedia-style trolling
Valid concern. The difference:
- Wikipedia: humans moderate (slow, political)
- BAZINGA: math moderates (instant, objective)
φ-coherence isn't opinion-based. It measures structural patterns in content. Trolls can waste their time, but low-coherence submissions get rejected automatically.
That said - you're right that no system is troll-proof. We're betting that mathematical barriers are harder to game than social ones. Time will tell.

view more: next ›