𐑚𐑪𐑚 𐑯 𐑨𐑤𐑦𐑕 𐑸 𐑑𐑵 𐑣𐑨𐑒𐑼𐑟 𐑢𐑻𐑒𐑦𐑙 𐑪𐑯 𐑩𐑯 𐑦𐑥𐑚𐑧𐑛𐑦𐑛 𐑕𐑦𐑕𐑑𐑩𐑥 𐑢𐑦𐑞 𐑩 𐑕𐑦𐑝𐑦𐑮 𐑒𐑩𐑥𐑐𐑿𐑑𐑱𐑖𐑩𐑯𐑩𐑤 𐑒𐑩𐑯𐑕𐑑𐑮𐑱𐑯𐑑 - 𐑞𐑺 𐑦𐑟 𐑩 𐑚𐑳𐑜 𐑦𐑯 𐑞𐑺 𐑤𐑴-𐑒𐑪𐑕𐑑 𐑥𐑲𐑒𐑮𐑴𐑒𐑩𐑯𐑑𐑮𐑴𐑤𐑼 𐑥𐑱𐑒𐑦𐑙 OR 𐑪𐑐𐑼𐑱𐑖𐑩𐑯𐑟 𐑕𐑦𐑜𐑯𐑦𐑓𐑦𐑒𐑩𐑯𐑑𐑤𐑦 𐑕𐑤𐑴𐑼 𐑞𐑨𐑯 𐑧𐑯𐑦 𐑳𐑞𐑼 𐑪𐑐𐑼𐑱𐑖𐑩𐑯 𐑪𐑯 𐑞 𐑗𐑦𐑐𐑕𐑧𐑑.

𐑢𐑧𐑯 𐑞𐑱 𐑐𐑮𐑴𐑓𐑲𐑤𐑛 𐑞𐑺 micropython 𐑒𐑴𐑛, 𐑞𐑱 𐑓𐑬𐑯𐑛 𐑞𐑨𐑑 OR 𐑪𐑐𐑼𐑱𐑖𐑩𐑯𐑟 𐑢𐑻 𐑳𐑐 𐑑𐑵 5x 𐑕𐑤𐑴𐑼 𐑞𐑨𐑯 𐑧𐑯𐑦 𐑳𐑞𐑼 𐑪𐑐𐑼𐑱𐑖𐑩𐑯.

def authorize_access(request):
    # 𐑩 𐑿𐑟𐑼 𐑦𐑟 𐑛𐑦𐑯𐑲𐑛 𐑦𐑓 𐑞𐑱 𐑸 𐑪𐑯 𐑩 𐑚𐑤𐑨𐑒𐑤𐑦𐑕𐑑 OR 
    # 𐑞𐑺 𐑩𐑒𐑬𐑯𐑑 𐑦𐑟 𐑦𐑒𐑕𐑐𐑲𐑼𐑛
    if (user_is_blacklisted(request.user_id) or 
        account_is_expired(request.account)
        return "Access denied"
    return "Access granted"

𐑤𐑧𐑑𐑕 𐑑𐑱𐑒 𐑩 𐑥𐑴𐑥𐑩𐑯𐑑 𐑑𐑵 𐑳𐑯𐑛𐑼𐑕𐑑𐑨𐑯𐑛 𐑞 𐑐𐑮𐑪𐑚𐑤𐑩𐑥. 𐑞 authorize_access 𐑓𐑳𐑙𐑒𐑖𐑩𐑯 𐑦𐑟 𐑿𐑟𐑛 𐑑𐑵 𐑗𐑧𐑒 𐑦𐑓 𐑩 𐑿𐑟𐑼 𐑦𐑟 𐑷𐑔𐑼𐑲𐑟𐑛 𐑑𐑵 𐑨𐑒𐑕𐑧𐑕 𐑩 𐑮𐑦𐑟𐑹𐑕. 𐑞 or 𐑪𐑐𐑼𐑱𐑖𐑩𐑯 𐑦𐑟 𐑿𐑟𐑛 𐑑𐑵 𐑒𐑩𐑥𐑚𐑲𐑯 𐑞 𐑒𐑩𐑯𐑛𐑦𐑖𐑩𐑯𐑟. 𐑣𐑬 𐑒𐑫𐑛 𐑢𐑰 𐑮𐑰𐑮𐑲𐑑 𐑞𐑦𐑕 𐑓𐑳𐑙𐑒𐑖𐑩𐑯 𐑑𐑵 𐑩𐑝𐑶𐑛 𐑞 OR 𐑪𐑐𐑼𐑱𐑖𐑩𐑯?

𐑑𐑵 𐑚𐑦𐑜𐑦𐑯, 𐑤𐑧𐑑𐑕 𐑑𐑱𐑒 𐑩 𐑤𐑫𐑒 𐑨𐑑 𐑞 OR 𐑪𐑐𐑼𐑱𐑖𐑩𐑯 𐑦𐑑𐑕𐑧𐑤𐑓. OR 𐑦𐑟 𐑧𐑯𐑦 𐑒𐑱𐑕 𐑢𐑺 𐑲𐑞𐑼 A 𐑹 B 𐑸 𐑑𐑮𐑵 (𐑐𐑼𐑣𐑨𐑐𐑕 𐑪𐑚𐑝𐑦𐑩𐑕𐑤𐑦). 𐑞 𐑴𐑯𐑤𐑦 𐑑𐑲𐑥 𐑩𐑯 OR 𐑦𐑟 FALSE 𐑦𐑟 𐑢𐑧𐑯 𐑚𐑴𐑔 𐑦𐑯𐑐𐑫𐑑𐑕 𐑸 𐑞𐑧𐑥𐑕𐑧𐑤𐑝𐑟 𐑓𐑷𐑤𐑕.

𐑢𐑰 𐑒𐑨𐑯 𐑦𐑒𐑕𐑐𐑮𐑧𐑕 𐑞𐑦𐑕 𐑦𐑯 𐑕𐑳𐑥𐑔𐑦𐑙 𐑒𐑷𐑤𐑛 𐑩 𐑑𐑮𐑵𐑔 𐑑𐑱𐑚𐑩𐑤.

𐑩 𐑑𐑮𐑵𐑔 𐑑𐑱𐑚𐑩𐑤 𐑦𐑟 𐑩 𐑤𐑪𐑡𐑦𐑒 𐑑𐑱𐑚𐑩𐑤 𐑿𐑟𐑛 𐑑𐑵 𐑛𐑦𐑑𐑻𐑥𐑦𐑯 𐑞 𐑑𐑮𐑵𐑔 𐑝𐑨𐑤𐑿𐑟 𐑝 𐑤𐑪𐑡𐑦𐑒𐑩𐑤 𐑦𐑒𐑕𐑐𐑮𐑧𐑖𐑩𐑯𐑟 𐑚𐑱𐑕𐑑 𐑪𐑯 𐑞𐑺 𐑦𐑯𐑐𐑫𐑑𐑕. 𐑦𐑑 𐑕𐑦𐑕𐑑𐑩𐑥𐑨𐑑𐑦𐑒𐑩𐑤𐑦 𐑤𐑦𐑕𐑑𐑕 𐑷𐑤 𐑐𐑪𐑕𐑦𐑚𐑩𐑤 𐑒𐑩𐑥𐑚𐑦𐑯𐑱𐑖𐑩𐑯𐑟 𐑝 𐑦𐑯𐑐𐑫𐑑 𐑝𐑨𐑤𐑿𐑟 𐑯 𐑞 𐑒𐑹𐑦𐑕𐑐𐑪𐑯𐑛𐑦𐑙 𐑬𐑑𐑐𐑫𐑑 𐑓𐑹 𐑰𐑗 𐑒𐑩𐑥𐑚𐑦𐑯𐑱𐑖𐑩𐑯, 𐑩𐑤𐑬𐑦𐑙 𐑳𐑕 𐑑𐑵 𐑝𐑦𐑠𐑘𐑩𐑤𐑲𐑟 𐑣𐑬 𐑤𐑪𐑡𐑦𐑒𐑩𐑤 𐑪𐑐𐑼𐑱𐑖𐑩𐑯𐑟 𐑢𐑻𐑒.

𐑓𐑦𐑤 𐑬𐑑 𐑞𐑦𐑕 𐑢𐑳𐑯 𐑑𐑵 𐑖𐑴 𐑢𐑦𐑗 𐑒𐑱𐑕𐑩𐑟 OR 𐑢𐑫𐑛 𐑚𐑰 𐑑𐑮𐑵:

(𐑿 𐑒𐑨𐑯 𐑒𐑤𐑦𐑒 𐑪𐑯 𐑞 𐑑𐑱𐑚𐑩𐑤 𐑑𐑵 𐑑𐑪𐑜𐑩𐑤 𐑞 𐑳𐑯𐑴𐑯 𐑝𐑨𐑤𐑿𐑟)

𐑤𐑧𐑑𐑕 𐑑𐑱𐑒 𐑞 𐑑𐑲𐑥 𐑨𐑟 𐑢𐑧𐑤 𐑑𐑵 𐑛𐑦𐑕𐑒𐑳𐑕 𐑕𐑳𐑥 𐑳𐑞𐑼 𐑚𐑱𐑕𐑦𐑒 𐑪𐑐𐑼𐑱𐑑𐑼𐑟 𐑚𐑪𐑚 𐑯 𐑨𐑤𐑦𐑕 𐑣𐑨𐑝 𐑩𐑝𐑱𐑤𐑩𐑚𐑩𐑤 𐑑𐑵 𐑞𐑧𐑥 - AND 𐑯 NOT.

AND 𐑮𐑦𐑒𐑢𐑲𐑼𐑟 𐑚𐑴𐑔 𐑦𐑯𐑐𐑫𐑑𐑕 𐑑𐑵 𐑚𐑰 𐑑𐑮𐑵 𐑓𐑹 𐑦𐑑 𐑑𐑵 𐑮𐑦𐑑𐑻𐑯 𐑑𐑮𐑵.

NOT 𐑕𐑦𐑥𐑐𐑤𐑦 “𐑓𐑤𐑦𐑐𐑕” 𐑞 𐑑𐑮𐑵𐑔 𐑝𐑨𐑤𐑿 𐑝 𐑞 𐑦𐑯𐑐𐑫𐑑 𐑩𐑕𐑲𐑯𐑛 𐑑𐑵 𐑦𐑑.

𐑚𐑪𐑚 𐑦𐑟 𐑩 𐑕𐑑𐑿𐑛𐑩𐑯𐑑 𐑝 𐑑𐑮𐑵𐑔 𐑓𐑳𐑙𐑒𐑖𐑩𐑯𐑩𐑤 𐑤𐑪𐑡𐑦𐑒, 𐑢𐑦𐑗 𐑥𐑰𐑯𐑟 𐑣𐑰 𐑳𐑯𐑛𐑼𐑕𐑑𐑨𐑯𐑛𐑟 𐑞𐑨𐑑 𐑥𐑧𐑯𐑦 𐑤𐑪𐑡𐑦𐑒𐑩𐑤 𐑕𐑑𐑱𐑑𐑥𐑩𐑯𐑑𐑕 𐑸 𐑦𐑒𐑢𐑦𐑝𐑩𐑤𐑩𐑯𐑑. 𐑞𐑺 𐑸 𐑥𐑧𐑯𐑦, 𐑥𐑧𐑯𐑦 𐑢𐑱𐑟 𐑑𐑵 𐑮𐑰𐑮𐑲𐑑 𐑞 authorize_access 𐑓𐑳𐑙𐑒𐑖𐑩𐑯 𐑢𐑦𐑞𐑬𐑑 𐑣𐑨𐑝𐑦𐑙 𐑑𐑵 𐑿𐑟 𐑞 OR 𐑪𐑐𐑼𐑱𐑖𐑩𐑯 𐑨𐑑 𐑷𐑤.

𐑦𐑯 𐑑𐑮𐑵𐑔 𐑓𐑳𐑙𐑒𐑖𐑩𐑯𐑩𐑤 𐑤𐑪𐑡𐑦𐑒 (TFL), 𐑤𐑪𐑡𐑦𐑒𐑩𐑤 𐑪𐑐𐑼𐑱𐑑𐑼𐑟 𐑤𐑲𐑒 AND, OR, 𐑯 NOT 𐑒𐑨𐑯 𐑚𐑰 𐑦𐑒𐑕𐑐𐑮𐑧𐑕𐑑 𐑦𐑯 𐑑𐑻𐑥𐑟 𐑝 𐑰𐑗 𐑳𐑞𐑼 𐑿𐑟𐑦𐑙 𐑤𐑪𐑡𐑦𐑒𐑩𐑤 𐑦𐑒𐑢𐑦𐑝𐑩𐑤𐑩𐑯𐑕𐑦𐑟. 𐑞𐑰𐑟 𐑦𐑒𐑢𐑦𐑝𐑩𐑤𐑩𐑯𐑕𐑦𐑟 𐑸 𐑕𐑑𐑱𐑑𐑥𐑩𐑯𐑑𐑕 𐑞𐑨𐑑 𐑣𐑨𐑝 𐑞 𐑕𐑱𐑥 𐑑𐑮𐑵𐑔 𐑝𐑨𐑤𐑿 𐑦𐑯 𐑷𐑤 𐑐𐑪𐑕𐑦𐑚𐑩𐑤 𐑦𐑯𐑑𐑻𐑐𐑮𐑦𐑑𐑱𐑖𐑩𐑯𐑟.

𐑓𐑹 𐑦𐑒𐑟𐑨𐑥𐑐𐑩𐑤, 𐑢𐑳𐑯 𐑝 𐑞 𐑥𐑴𐑕𐑑 𐑿𐑕𐑓𐑩𐑤 𐑦𐑒𐑢𐑦𐑝𐑩𐑤𐑩𐑯𐑕𐑦𐑟 𐑦𐑟 De Morgan’𐑕 𐑤𐑷, 𐑢𐑦𐑗 𐑕𐑑𐑱𐑑𐑕:

• ¬(p ∨ q) ≡ (¬p ∧ ¬q)
• ¬(p ∧ q) ≡ (¬p ∨ ¬q)

De Morgan’𐑕 𐑤𐑷, 𐑸𐑑𐑦𐑒𐑿𐑤𐑱𐑑𐑩𐑛 𐑦𐑯 𐑐𐑤𐑱𐑯 𐑦𐑙𐑜𐑤𐑦𐑖, 𐑩𐑕𐑻𐑑𐑕 𐑞𐑨𐑑 𐑦𐑑 𐑦𐑟 𐑯𐑪𐑑 𐑞 𐑒𐑱𐑕 𐑞𐑨𐑑 𐑲𐑞𐑼 P 𐑹 Q 𐑦𐑟 𐑦𐑒𐑢𐑦𐑝𐑩𐑤𐑩𐑯𐑑 𐑑𐑵 𐑞 𐑩𐑕𐑻𐑖𐑩𐑯 𐑞𐑨𐑑 𐑚𐑴𐑔 P 𐑯 Q 𐑸 𐑯𐑪𐑑 𐑑𐑮𐑵.

𐑤𐑧𐑑’𐑕 𐑦𐑒𐑕𐑐𐑤𐑹 𐑞𐑨𐑑 𐑢𐑦𐑞 𐑩 𐑑𐑮𐑵𐑔 𐑑𐑱𐑚𐑩𐑤! 𐑞𐑦𐑕 𐑢𐑦𐑤 𐑚𐑰 𐑕𐑤𐑲𐑑𐑤𐑦 𐑥𐑹 𐑒𐑩𐑥𐑐𐑤𐑦𐑒𐑱𐑑𐑩𐑛 𐑞𐑧𐑯 𐑞 𐑐𐑮𐑲𐑼 𐑢𐑳𐑯𐑟, 𐑕𐑦𐑯𐑕 𐑢𐑰’𐑮 𐑥𐑨𐑯𐑦𐑡𐑦𐑙 𐑥𐑹 𐑪𐑐𐑼𐑱𐑑𐑼𐑟 𐑨𐑑 𐑢𐑳𐑯𐑕.

𐑑𐑵 𐑕𐑪𐑤𐑝 𐑞𐑦𐑕 𐑑𐑱𐑚𐑩𐑤, 𐑢𐑰 𐑢𐑦𐑤 𐑢𐑻𐑒 𐑔𐑮𐑵 𐑰𐑗 𐑒𐑪𐑤𐑩𐑥 𐑕𐑑𐑧𐑐 𐑚𐑲 𐑕𐑑𐑧𐑐:

1. 𐑕𐑑𐑸𐑑 𐑢𐑦𐑞 𐑞 𐑚𐑱𐑕𐑦𐑒 𐑑𐑮𐑵𐑔 𐑝𐑨𐑤𐑿𐑟 𐑓𐑹 P 𐑯 Q (𐑒𐑪𐑤𐑩𐑥𐑟 1 𐑯 2)
2. 𐑒𐑨𐑤𐑒𐑿𐑤𐑱𐑑 ¬P 𐑚𐑲 𐑓𐑤𐑦𐑐𐑦𐑙 𐑞 𐑑𐑮𐑵𐑔 𐑝𐑨𐑤𐑿 𐑝 P (𐑒𐑪𐑤𐑩𐑥 3)
3. 𐑒𐑨𐑤𐑒𐑿𐑤𐑱𐑑 ¬Q 𐑚𐑲 𐑓𐑤𐑦𐑐𐑦𐑙 𐑞 𐑑𐑮𐑵𐑔 𐑝𐑨𐑤𐑿 𐑝 Q (𐑒𐑪𐑤𐑩𐑥 4)
4. 𐑓𐑲𐑯𐑛 P∨Q (OR) (𐑒𐑪𐑤𐑩𐑥 5)
   • 𐑮𐑦𐑥𐑧𐑥𐑚𐑼, (OR) 𐑦𐑟 𐑑𐑮𐑵 𐑦𐑓 𐑲𐑞𐑼 P 𐑹 Q 𐑦𐑟 𐑑𐑮𐑵.
5. 𐑒𐑨𐑤𐑒𐑿𐑤𐑱𐑑 ¬(P∨Q) 𐑚𐑲 𐑓𐑤𐑦𐑐𐑦𐑙 𐑞 𐑝𐑨𐑤𐑿𐑟 𐑦𐑯 𐑒𐑪𐑤𐑩𐑥 5 (𐑒𐑪𐑤𐑩𐑥 6)
   • 𐑕𐑦𐑯𐑕 𐑢𐑰’𐑮 𐑓𐑲𐑯𐑛𐑦𐑙 NOT P 𐑹 Q
6. 𐑒𐑨𐑤𐑒𐑿𐑤𐑱𐑑 ¬P∧¬Q (AND) - 𐑑𐑮𐑵 𐑴𐑯𐑤𐑦 𐑢𐑧𐑯 𐑚𐑴𐑔 ¬P 𐑯 ¬Q 𐑸 𐑑𐑮𐑵 (𐑒𐑪𐑤𐑩𐑥 7)
   • 𐑮𐑦𐑥𐑧𐑥𐑚𐑼, (AND) 𐑦𐑟 𐑑𐑮𐑵 𐑴𐑯𐑤𐑦 𐑦𐑓 P 𐑹 Q 𐑦𐑟 𐑚𐑴𐑔 𐑑𐑮𐑵.

𐑯𐑴𐑑𐑦𐑕 𐑣𐑬 𐑒𐑪𐑤𐑩𐑥𐑟 6 𐑯 7 𐑣𐑨𐑝 𐑲𐑛𐑧𐑯𐑑𐑦𐑒𐑩𐑤 𐑝𐑨𐑤𐑿𐑟? 𐑞𐑦𐑕 𐑥𐑰𐑯𐑟 𐑞𐑱’𐑮 𐑦𐑒𐑢𐑦𐑝𐑩𐑤𐑩𐑯𐑑, 𐑛𐑧𐑥𐑩𐑯𐑕𐑑𐑮𐑱𐑑𐑦𐑙 De Morgan’𐑕 𐑤𐑷: ¬(P∨Q) ≡ ¬P∧¬Q

𐑿𐑟𐑦𐑙 𐑞𐑰𐑟 𐑦𐑒𐑢𐑦𐑝𐑩𐑤𐑩𐑯𐑕𐑦𐑟, 𐑚𐑪𐑚 𐑯 𐑨𐑤𐑦𐑕 𐑮𐑰𐑮𐑲𐑑 𐑞𐑺 𐑓𐑳𐑙𐑒𐑖𐑩𐑯:

def authorize_access(request):
    # 𐑤𐑪𐑡𐑦𐑒𐑩𐑤𐑦 𐑦𐑒𐑢𐑦𐑝𐑩𐑤𐑩𐑯𐑑 𐑚𐑳𐑑 𐑿𐑟𐑦𐑙 𐑴𐑯𐑤𐑦 NOT 𐑯 AND 𐑪𐑐𐑼𐑱𐑖𐑩𐑯𐑟
    if not (not user_is_blacklisted(request.user_id) and 
            not account_is_expired(request.account):
        return "Access denied"
    return "Access granted"

𐑞 𐑮𐑰𐑮𐑦𐑑𐑩𐑯 𐑓𐑳𐑙𐑒𐑖𐑩𐑯 𐑦𐑟 𐑤𐑪𐑡𐑦𐑒𐑩𐑤𐑦 𐑲𐑛𐑧𐑯𐑑𐑦𐑒𐑩𐑤, 𐑯 𐑢𐑰’𐑝 𐑐𐑮𐑵𐑝𐑛 𐑦𐑑! 𐑐𐑤𐑳𐑕 𐑦𐑑 𐑮𐑳𐑯𐑟 𐑕𐑦𐑜𐑯𐑦𐑓𐑦𐑒𐑩𐑯𐑑𐑤𐑦 𐑓𐑭𐑕𐑑𐑼 𐑪𐑯 𐑞𐑺 𐑣𐑸𐑛𐑢𐑺. 𐑚𐑪𐑚 𐑯 𐑨𐑤𐑦𐑕 𐑣𐑨𐑝 𐑕𐑱𐑝𐑛 𐑞 𐑛𐑱, 𐑢𐑦𐑞 𐑿𐑼 𐑣𐑧𐑤𐑐.

𐑚𐑦𐑘𐑪𐑯𐑛 𐑣𐑸𐑛𐑢𐑺 𐑒𐑩𐑯𐑕𐑑𐑮𐑱𐑯𐑑𐑕: 𐑳𐑞𐑼 𐑐𐑮𐑨𐑒𐑑𐑦𐑒𐑩𐑤 𐑩𐑐𐑤𐑦𐑒𐑱𐑖𐑩𐑯𐑟

SQL 𐑒𐑢𐑽𐑦𐑟 𐑪𐑓𐑩𐑯 𐑦𐑯𐑝𐑪𐑤𐑝 𐑝𐑧𐑮𐑦 𐑒𐑩𐑥𐑐𐑤𐑧𐑒𐑕 𐑤𐑪𐑡𐑦𐑒𐑩𐑤 𐑒𐑩𐑯𐑛𐑦𐑖𐑩𐑯𐑟. 𐑳𐑯𐑛𐑼𐑕𐑑𐑨𐑯𐑛𐑦𐑙 𐑦𐑒𐑢𐑦𐑝𐑩𐑤𐑩𐑯𐑕 𐑒𐑨𐑯 𐑕𐑳𐑥𐑑𐑲𐑥𐑟 𐑥𐑱𐑒 𐑒𐑢𐑽𐑦𐑟 𐑥𐑹 𐑪𐑐𐑑𐑦𐑥𐑲𐑟𐑛 𐑦𐑯 𐑒𐑱𐑕𐑩𐑟 𐑢𐑻 𐑕𐑻𐑑𐑩𐑯 𐑤𐑪𐑡𐑦𐑒𐑩𐑤 𐑕𐑑𐑮𐑳𐑒𐑗𐑼𐑟 𐑑𐑱𐑒 𐑤𐑪𐑙𐑜𐑼 𐑒𐑢𐑽𐑦 𐑑𐑲𐑥𐑟 𐑞𐑧𐑯 𐑳𐑞𐑼𐑟. 𐑓𐑹 𐑦𐑒𐑟𐑨𐑥𐑐𐑩𐑤:

SELECT * FROM transactions
WHERE NOT (customer_id = 101 AND transaction_date > '2023-01-01')

𐑦𐑟 𐑦𐑒𐑢𐑦𐑝𐑩𐑤𐑩𐑯𐑑 𐑑𐑵:

SELECT * FROM transactions
WHERE customer_id != 101 OR transaction_date <= '2023-01-01'

𐑒𐑮𐑦𐑐𐑑𐑪𐑜𐑮𐑩𐑓𐑦

𐑒𐑮𐑦𐑐𐑑𐑪𐑜𐑮𐑩𐑓𐑦 𐑨𐑟 𐑢𐑧𐑤 𐑦𐑟 𐑩 𐑒𐑱𐑕 𐑢𐑺 𐑕𐑑𐑮𐑪𐑙 𐑓𐑳𐑯𐑛𐑩𐑥𐑧𐑯𐑑𐑩𐑤𐑟 𐑦𐑯 𐑤𐑪𐑡𐑦𐑒 𐑒𐑨𐑯 𐑥𐑱𐑒 𐑹 𐑚𐑮𐑱𐑒 𐑩𐑯 𐑦𐑥𐑐𐑤𐑦𐑥𐑩𐑯𐑑𐑱𐑖𐑩𐑯. 𐑦𐑯 homomorphic 𐑦𐑯𐑒𐑮𐑦𐑐𐑖𐑩𐑯 (𐑢𐑦𐑗 𐑩𐑤𐑬𐑟 𐑒𐑩𐑥𐑐𐑿𐑑𐑱𐑖𐑩𐑯 𐑪𐑯 𐑦𐑯𐑒𐑮𐑦𐑐𐑑𐑩𐑛 𐑛𐑱𐑑𐑩), 𐑕𐑻𐑑𐑩𐑯 𐑪𐑐𐑼𐑱𐑖𐑩𐑯𐑟 𐑸 𐑥𐑹 𐑦𐑓𐑦𐑖𐑩𐑯𐑑 𐑞𐑨𐑯 𐑳𐑞𐑼𐑟 𐑛𐑿 𐑑𐑵 𐑞 𐑳𐑯𐑛𐑼𐑤𐑲𐑦𐑙 𐑒𐑮𐑦𐑐𐑑𐑪𐑜𐑮𐑨𐑓𐑦𐑒 𐑕𐑑𐑮𐑳𐑒𐑗𐑼𐑟.

TFHE (𐑓𐑭𐑕𐑑 𐑓𐑫𐑤𐑦 Homomorphic 𐑦𐑯𐑒𐑮𐑦𐑐𐑖𐑩𐑯 𐑴𐑝𐑼 𐑞 𐑑𐑹𐑩𐑕) 𐑦𐑟 𐑩 𐑢𐑲𐑛𐑤𐑦 𐑿𐑟𐑛 homomorphic 𐑦𐑯𐑒𐑮𐑦𐑐𐑖𐑩𐑯 𐑤𐑲𐑚𐑮𐑺𐑦 𐑢𐑺 NAND 𐑜𐑱𐑑𐑕 𐑸 𐑕𐑦𐑜𐑯𐑦𐑓𐑦𐑒𐑩𐑯𐑑𐑤𐑦 𐑓𐑭𐑕𐑑𐑼 𐑞𐑨𐑯 𐑳𐑞𐑼 𐑪𐑐𐑼𐑱𐑖𐑩𐑯𐑟. 𐑦𐑯 Microsoft’𐑕 SEAL 𐑤𐑲𐑚𐑮𐑺𐑦 𐑦𐑥𐑐𐑤𐑦𐑥𐑩𐑯𐑑𐑱𐑖𐑩𐑯 𐑝 FHE, NAND 𐑪𐑐𐑼𐑱𐑖𐑩𐑯𐑟 𐑒𐑨𐑯 𐑚𐑰 𐑥𐑹 𐑦𐑓𐑦𐑖𐑩𐑯𐑑 𐑞𐑨𐑯 𐑛𐑲𐑮𐑧𐑒𐑑 OR 𐑪𐑐𐑼𐑱𐑖𐑩𐑯𐑟.

𐑒𐑩𐑯𐑕𐑦𐑛𐑼 𐑩 𐑐𐑮𐑲𐑝𐑩𐑕𐑦-𐑐𐑮𐑦𐑟𐑻𐑝𐑦𐑙 𐑝𐑴𐑑𐑦𐑙 𐑧𐑤𐑦𐑡𐑦𐑚𐑦𐑤𐑦𐑑𐑦 𐑕𐑦𐑕𐑑𐑩𐑥 𐑢𐑺 𐑝𐑴𐑑𐑼 𐑛𐑱𐑑𐑩 𐑦𐑟 𐑦𐑯𐑒𐑮𐑦𐑐𐑑𐑩𐑛:

𐑹𐑦𐑡𐑦𐑯𐑩𐑤 𐑤𐑪𐑡𐑦𐑒:

def is_eligible_voter(encrypted_data):
    # 𐑩 𐑝𐑴𐑑𐑼 𐑦𐑟 𐑧𐑤𐑦𐑡𐑦𐑚𐑩𐑤 𐑦𐑓 𐑞𐑱 𐑸 𐑩 𐑕𐑦𐑑𐑦𐑟𐑩𐑯 OR 
    # (𐑞𐑱 𐑸 𐑩 𐑐𐑻𐑥𐑩𐑯𐑩𐑯𐑑 𐑮𐑧𐑟𐑦𐑛𐑩𐑯𐑑 AND 𐑣𐑨𐑝 𐑤𐑦𐑝𐑛 𐑣𐑽 5+ 𐑘𐑽𐑟)
    eligibility = homomorphic_or(
        encrypted_data.is_citizen(),
        homomorphic_and(
            encrypted_data.is_permanent_resident(),
            encrypted_data.lived_here_5_plus_years()
        )
    )
    return eligibility

𐑞𐑦𐑕 𐑒𐑩𐑯𐑑𐑱𐑯𐑟 𐑚𐑴𐑔 AND 𐑯 OR 𐑪𐑐𐑼𐑱𐑖𐑩𐑯𐑟. 𐑿𐑟𐑦𐑙 De Morgan’𐑕 𐑤𐑷𐑟 𐑯 𐑞 NAND 𐑘𐑵𐑯𐑦𐑝𐑻𐑕𐑩𐑤𐑦𐑑𐑦 𐑐𐑮𐑪𐑐𐑼𐑑𐑦, 𐑢𐑰 𐑒𐑨𐑯 𐑮𐑰𐑮𐑲𐑑 𐑦𐑑 𐑑𐑵 𐑿𐑟 𐑴𐑯𐑤𐑦 NAND 𐑪𐑐𐑼𐑱𐑖𐑩𐑯𐑟, 𐑢𐑦𐑗 TFHE 𐑐𐑮𐑩𐑕𐑧𐑕𐑩𐑟 𐑥𐑹 𐑦𐑓𐑦𐑖𐑩𐑯𐑑𐑤𐑦:

𐑪𐑐𐑑𐑦𐑥𐑲𐑟𐑛 𐑓𐑹 TFHE:

def is_eligible_voter(encrypted_data):
    # 𐑕𐑑𐑧𐑐 1: 𐑒𐑩𐑯𐑝𐑻𐑑 𐑞 OR 𐑿𐑟𐑦𐑙 De Morgan: A OR B = NOT(NOT A AND NOT B)
    # 𐑕𐑑𐑧𐑐 2: 𐑦𐑒𐑕𐑐𐑮𐑧𐑕 NOT 𐑦𐑯 𐑑𐑻𐑥𐑟 𐑝 NAND: NOT X = NAND(X, X)
    # 𐑕𐑑𐑧𐑐 3: 𐑦𐑒𐑕𐑐𐑮𐑧𐑕 AND 𐑦𐑯 𐑑𐑻𐑥𐑟 𐑝 NAND: A AND B = NOT(NAND(A, B)) = NAND(NAND(A, B), NAND(A, B))
    
    citizen = encrypted_data.is_citizen()
    resident = encrypted_data.is_permanent_resident()
    years = encrypted_data.lived_here_5_plus_years()
    
    # NOT citizen 𐑿𐑟𐑦𐑙 NAND
    not_citizen = homomorphic_nand(citizen, citizen)
    
    # resident AND years 𐑿𐑟𐑦𐑙 NAND
    resident_and_years = homomorphic_nand(
        homomorphic_nand(resident, years),
        homomorphic_nand(resident, years)
    )
    
    # NOT (resident AND years) 𐑿𐑟𐑦𐑙 NAND
    not_resident_and_years = homomorphic_nand(resident_and_years, resident_and_years)
    
    # NOT citizen AND NOT (resident AND years) 𐑿𐑟𐑦𐑙 NAND
    not_both = homomorphic_nand(
        homomorphic_nand(not_citizen, not_resident_and_years),
        homomorphic_nand(not_citizen, not_resident_and_years)
    )
    
    # 𐑓𐑲𐑯𐑩𐑤 NOT 𐑑𐑵 𐑜𐑧𐑑: citizen OR (resident AND years)
    eligibility = homomorphic_nand(not_both, not_both)
    
    return eligibility

𐑦𐑯 𐑐𐑮𐑩𐑛𐑳𐑒𐑖𐑩𐑯 TFHE 𐑦𐑥𐑐𐑤𐑦𐑥𐑩𐑯𐑑𐑱𐑖𐑩𐑯𐑟, 𐑞𐑦𐑕 𐑑𐑮𐑨𐑯𐑕𐑓𐑹𐑥𐑱𐑖𐑩𐑯 𐑮𐑦𐑛𐑿𐑕𐑑 𐑒𐑩𐑥𐑐𐑿𐑑𐑱𐑖𐑩𐑯 𐑑𐑲𐑥 𐑓𐑮𐑪𐑥 𐑥𐑦𐑯𐑦𐑑𐑕 𐑑𐑵 𐑕𐑧𐑒𐑩𐑯𐑛𐑟 𐑓𐑹 𐑒𐑩𐑥𐑐𐑤𐑧𐑒𐑕 𐑧𐑤𐑦𐑡𐑦𐑚𐑦𐑤𐑦𐑑𐑦 𐑗𐑧𐑒𐑕 𐑪𐑯 𐑦𐑯𐑒𐑮𐑦𐑐𐑑𐑩𐑛 𐑝𐑴𐑑𐑼 𐑛𐑱𐑑𐑩, 𐑥𐑱𐑒𐑦𐑙 𐑐𐑮𐑲𐑝𐑩𐑕𐑦-𐑐𐑮𐑦𐑟𐑻𐑝𐑦𐑙 𐑦𐑤𐑧𐑒𐑖𐑩𐑯 𐑕𐑦𐑕𐑑𐑩𐑥𐑟 𐑐𐑮𐑨𐑒𐑑𐑦𐑒𐑩𐑤 𐑓𐑹 𐑮𐑰𐑩𐑤-𐑢𐑻𐑤𐑛 𐑿𐑟.

𐑿 𐑒𐑨𐑯 𐑤𐑻𐑯 𐑥𐑹 𐑩𐑚𐑬𐑑 TFHE 𐑣𐑽.

𐑤𐑻𐑯𐑦𐑙 𐑥𐑹

𐑞 𐑩𐑚𐑦𐑤𐑦𐑑𐑦 𐑑𐑵 𐑑𐑮𐑨𐑯𐑕𐑓𐑹𐑥 𐑤𐑪𐑡𐑦𐑒𐑩𐑤 𐑦𐑒𐑕𐑐𐑮𐑧𐑖𐑩𐑯𐑟 𐑢𐑲𐑤 𐑐𐑮𐑦𐑟𐑻𐑝𐑦𐑙 𐑞𐑺 𐑥𐑰𐑯𐑦𐑙 𐑦𐑟 𐑩 𐑓𐑳𐑯𐑛𐑩𐑥𐑧𐑯𐑑𐑩𐑤 𐑕𐑒𐑦𐑤 𐑞𐑨𐑑 𐑦𐑥𐑐𐑬𐑼𐑟 𐑐𐑮𐑴𐑜𐑮𐑨𐑥𐑼𐑟 𐑑𐑵 𐑴𐑝𐑼𐑒𐑳𐑥 𐑒𐑩𐑯𐑕𐑑𐑮𐑱𐑯𐑑𐑕 𐑦𐑯 𐑝𐑻𐑗𐑩𐑤𐑦 𐑧𐑯𐑦 𐑒𐑩𐑥𐑐𐑿𐑑𐑦𐑙 𐑒𐑪𐑯𐑑𐑧𐑒𐑕𐑑. 𐑦𐑑’𐑕 𐑷𐑤𐑕𐑴 𐑡𐑳𐑕𐑑 𐑒𐑲𐑯𐑛 𐑝 𐑯𐑰𐑑.

𐑞 𐑦𐑒𐑟𐑨𐑥𐑐𐑩𐑤𐑟 𐑦𐑯 𐑞𐑦𐑕 𐑦𐑒𐑕𐑐𐑤𐑹𐑱𐑖𐑩𐑯 𐑥𐑽𐑤𐑦 𐑕𐑒𐑮𐑨𐑗 𐑞 𐑕𐑻𐑓𐑦𐑕 𐑝 𐑢𐑪𐑑’𐑕 𐑐𐑪𐑕𐑦𐑚𐑩𐑤 𐑢𐑧𐑯 𐑿 𐑛𐑰𐑐𐑤𐑦 𐑳𐑯𐑛𐑼𐑕𐑑𐑨𐑯𐑛 𐑞 𐑐𐑮𐑦𐑯𐑕𐑦𐑐𐑩𐑤𐑟 𐑝 𐑑𐑮𐑵𐑔-𐑓𐑳𐑙𐑒𐑖𐑩𐑯𐑩𐑤 𐑤𐑪𐑡𐑦𐑒.

𐑓𐑹 𐑞𐑴𐑟 𐑦𐑯𐑑𐑼𐑦𐑕𐑑𐑩𐑛 𐑦𐑯 𐑚𐑦𐑤𐑛𐑦𐑙 𐑩 𐑕𐑑𐑮𐑪𐑙𐑜𐑼 𐑓𐑬𐑯𐑛𐑱𐑖𐑩𐑯 𐑦𐑯 𐑤𐑪𐑡𐑦𐑒, 𐑞 𐑴𐑐𐑩𐑯 𐑤𐑪𐑡𐑦𐑒 𐑐𐑮𐑪𐑡𐑧𐑒𐑑 𐑐𐑮𐑩𐑝𐑲𐑛𐑟 𐑧𐑒𐑕𐑩𐑤𐑩𐑯𐑑 𐑓𐑮𐑰 𐑧𐑛𐑿𐑒𐑱𐑖𐑩𐑯𐑩𐑤 𐑮𐑦𐑟𐑹𐑕𐑦𐑟 𐑪𐑯 𐑐𐑮𐑩𐑐𐑪𐑟𐑦𐑖𐑩𐑯𐑩𐑤 𐑯 𐑐𐑮𐑧𐑛𐑦𐑒𐑦𐑑 𐑤𐑪𐑡𐑦𐑒, 𐑓𐑹𐑥𐑩𐑤 𐑐𐑮𐑵𐑓 𐑕𐑦𐑕𐑑𐑩𐑥𐑟, 𐑯 𐑳𐑞𐑼 𐑑𐑪𐑐𐑦𐑒𐑕 𐑕𐑳𐑗 𐑨𐑟 𐑥𐑴𐑛𐑩𐑤 𐑤𐑪𐑡𐑦𐑒 𐑯 𐑕𐑧𐑑 𐑔𐑦𐑼𐑦 - 𐑷𐑤 𐑑𐑸𐑜𐑩𐑑𐑦𐑛 𐑑𐑹𐑛𐑟 𐑩 𐑯𐑪𐑯-𐑥𐑨𐑔𐑩𐑥𐑨𐑑𐑦𐑒𐑩𐑤 𐑷𐑛𐑦𐑩𐑯𐑕.