2₃ = ❓HEXAÇÃO - VALORES ABSURDOS - aprenda agora mesmo

[@carlosluizdeazevedoazevedo1614]

Excelente!

[@h1i2n3p4j5r6]

muio intteressante,essas operações não conhecia.

[@reginafalcao7172]

Amigo,tenho 76 anos,sou professora e estou "arrebentando" em suas aulas que contém novidades...Muito obrigada!!

[@ivairsouza787]

Isso me deu uma tentação para aprender! Parabéns pela ótima explicação!

[@familiagondim9557]

Gostei bastante da aula,parabéns👏

[@mistergonzaga9558]

Pirei nessa! Vou tentar entender!

[@valdemyribeiro5357]

Bom dia professor Silvio Paulo!
Obrigado por mais um maravilhoso vídeo com essa nova operação. Adorei! 17:30 17:30

[@miryanbulgarelli6661]

Vc tem uma ótima didática.

[@artandata]

time=16:45 faltou indicar que a soma de 2+2 também é 4

[@Fillipi777]

Eu já ia questionar a questão da tetração sobre outra, porque pensei que você tinha multiplicado os expoentes.
Mas você explicou no final e realmente dá o 4. Sempre deve lembrar que não se deve multiplicar os expoentes nas tetração, pentação e hexação. Somente na potenciação.

[@jacisilvaalbernazbezerra8905]

Muito legal professor, gostei muito dessa aula.

[@mistergonzaga9558]

Pirei nessa. Vou tentar entender.

[@AnneJoepen]

Dear professor now I have gotten into trouble for the first time .Hexacao I can only solve with your help because it is so well explained .

[@ledamarrenno]

Amei o vídeo de hoje 👏🏻❤

[@jenicadiac968]

INTERESANT !

[@BRUNOOLIVEIRA-mt5ee]

Excelente trabalho

[@faustof3]

Aprender nunca é de mais e não acumula espaço, mas com todo respeito ao professor e carinho com a matemática. Esse cálculo do "Exação" serve para ser aplicado onde...?

[@renatootaviosilvafranco5704]

Bastante interessante e o que mais impressiona são esses valores astronômicos.

[@LetíciaFisioterapia]

Aprendi todas essas agora

[@RenataGuimaraesLima]

kkkkkkkkkkkkkkkkkkkk

[@Rafael_Crisostomo963]

Usado em qual área? Hexação essa ferramenta é usado em que?

[@brunomartins4902]

existe algum uso para essas operações? ou só uma curiosidade matemática?

[@DavidPrietoElorza]

Obrigado no sabia disso.

[@tiaozinho3551]

Sua aula de hoje foi excepcional. Será que dá para você me responder a pergunta que eu fiz no vídeo de ontem? Depois da Hexação qual é o próximo Tópico? Você também poderia fazer um vídeo completo com todas essas operações.

[@vinizin_math]

Depois é a Heptação e são infinitas operações

[@MrKula-0028]

​@@vinizin_mathE onde o expoente ficaria na heptação?

[@tiaozinho3551]

@@vinizin_math Obrigado pela atenção e resposta. Espero que o nosso professor traga ao canal. Se não trouxer eu vou perturbar ele até trazer. 👍👍

[@jorgeluizpereira7526]

Vou salvar o vídeo, pois a aula de hoje precisa mais revisão.

[@AnneJoepen]

I think it also

[@lucianohabil]

Noooosssssaaaa! Gigantesco!

[@Daniel91953574]

forma geral:
ᵏₘxʲₙ
2³ = 2^3 = 2↑3 (pra comparação com um sistema mais robusto) #exponenciação
³2 = 2^{2^3}3 = 2↑↑3 #tetração
₃2 = 2^{2^{2^3}3}3 = 2↑↑↑3 #pentação
2₃ = 2^{2^{2^{2^3}}} = 2↑↑↑↑3 #hexação
#uma outra forma de representar caso seja dificil representar na forma anterior, formato lista de iterações, como lista superescrita;
2²'³'⁴'⁵'⁶ = 2^2^3^4^5^6 (pode crescer indefinidamente)
2↑ⁿ3 onde n=1 exponenciação, n=2 tetração, n=3 pentação, n=4 hexação, n é a n-ésima iteração(usa a mesma regra de usar numero da base pra preencher valores);
também é possível generalizar a notação de knuth para crescer sobre sua própria exponencial:
2^(↑ⁿ)3 = 2↑^{2↑ⁿ3}3
*veja outras notações sobre hiperoperação, como a função de graham G(n) que itera sobre as camadas de n_knuth(a,b,n)
e respondendo a questão 2^2^...{65536}^2 é (2^256)^(2^256)^...{256}^(2^256), que pode ser representado como uma sequencia de 256 exponenciais de 115792089237316195423570985008687907853269984665640564039457584007913129639936,
descrição como função das operações citadas anteriormente:
*uma pequena diferença é que eu não conto o valor inicial, é uma pequena diferença, isso ocorre pois a operação da base da notação de setas é a exponenciação, enquanto nas iterações citadas é multiplicação;
#funciona no python, dá para fazer calculos reais, insira as duas linhas asseguir se for usar
import sys
import math
sys.set_int_max_str_digits(0)
# Função Knuth recursiva
def knuth_up_arrow(base, exponent, arrows):
if arrows == 1:return math.pow(base, exponent)
elif arrows > 1:
result = base
for _ in range(int(exponent) - 1):result = knuth_up_arrow(base, result, arrows - 1)
return result
# Função Graham recursiva
def graham_recursive(n):
if n == 1:return knuth_up_arrow(3, 3, 3)
else:return knuth_up_arrow(3, graham_recursive(n - 1), 2)
# Função de Ackermann
def ackermann(m, n):
if m == 0:return n + 1
elif n == 0:return ackermann(m - 1, 1)
else:return ackermann(m - 1, ackermann(m, n - 1))
# Função de Fatorial
def factorial(n):
if n == 0 or n == 1:return 1
else:return n * factorial(n - 1)
#Função F(n,n,n,n,n,n,n,n,n,n,n) generaliza as funções anteriores tudo junto, além de inserir hiper-recursão, se sua intenção é saber como expressar o maior numero possível ainda mantendo algum tipo de controle, e não apenas afirmações vagas como maior numero expressável em 100 letras(o código asseguir é de minha autoria mas as funcionalidades não são originais):
def hiperrecursivo(a, b, k):
pilha = [{"a": a, "b": b, "k": k, "etapa": 0}]
resultado_final = None # Adicionar uma variável para armazenar o resultado final
while pilha:
estado = pilha[-1]
a = estado["a"]
b = estado["b"]
k = estado["k"]
etapa = estado["etapa"]
if etapa == 0:
if k == 1:
estado["resultado"] = a ** b
resultado_final = estado["resultado"] # Armazenar o resultado
pilha.pop()
if pilha:
pilha[-1]["resultado"] = resultado_final
elif b == 0:
estado["resultado"] = 1
resultado_final = estado["resultado"] # Armazenar o resultado
pilha.pop()
if pilha:
pilha[-1]["resultado"] = resultado_final
else:
estado["etapa"] = 1
pilha.append({"a": a, "b": b - 1, "k": k, "etapa": 0})
elif etapa == 1:
if "resultado" in estado:
estado["etapa"] = 0
estado["b"] = estado["resultado"]
pilha.append({"a": a, "b": estado["resultado"], "k": k - 1, "etapa": 0})
return resultado_final
def F(n, m, o, a, b, p_down, l_down, m_top, i_arrow, j_top, q):
stack = [(n, m, o, a, b, p_down, l_down, m_top, i_arrow, j_top, q, 'init')]
results = {}
while stack:
current = stack.pop()
if isinstance(current, tuple):
current_n, current_m, current_o, current_a, current_b, current_p_down, current_l_down, current_m_top, current_i_arrow, current_j_top, current_q, state = current
else:
current_n, current_m, current_o, current_a, current_b, current_p_down, current_l_down, current_m_top, current_i_arrow, current_j_top, current_q = current
state = None
key = (current_n, current_m, current_o, current_a, current_b, current_p_down, current_l_down, current_m_top, current_i_arrow, current_j_top, current_q)
if state == 'init':
if key in results:
continue
if current_n 0 and current_o == 0:
stack.append((current_n, current_m, current_o, current_a, current_b, current_p_down, current_l_down, current_m_top, current_i_arrow, current_j_top, current_q, 'm_gt_zero_o_zero'))
stack.append((current_n - 1, current_m - 1, 1, current_a, current_b, current_p_down, current_l_down, current_m_top, current_i_arrow, current_j_top, current_q, 'init'))
else:
stack.append((current_n, current_m, current_o, current_a, current_b, current_p_down, current_l_down, current_m_top, current_i_arrow, current_j_top, current_q, 'm_else'))
stack.append((current_n - 1, current_m, current_o, current_a, current_b, current_p_down, current_l_down, current_m_top, current_i_arrow, current_j_top, current_q, 'init'))
elif state == 'm_zero':
i = results[(current_n - 1, 1, current_o, current_a, current_b, current_p_down, current_l_down, current_m_top, current_i_arrow, current_j_top, current_q)] + 1
r = 0
loop_limit = 3 * results[(current_n - 1, 1, current_o, current_a, current_b, current_p_down, current_l_down, current_m_top, current_i_arrow, current_j_top, current_q)] + current_n + current_o + 1
while i < loop_limit:
r += 3 * results[(current_n - 1, 1, current_o, current_a, current_b, current_p_down, current_l_down, current_m_top, current_i_arrow, current_j_top, current_q)] + current_n + current_o + 1
i += 1
results[key] = r
elif state == 'm_gt_zero_o_zero':
i = results[(current_n - 1, current_m - 1, 1, current_a, current_b, current_p_down, current_l_down, current_m_top, current_i_arrow, current_j_top, current_q)] + 1
r = 0
loop_limit = 3 * results[(current_n - 1, current_m - 1, 1, current_a, current_b, current_p_down, current_l_down, current_m_top, current_i_arrow, current_j_top, current_q)] + current_n + current_o + 1
while i < loop_limit:
r += 3 * results[(current_n - 1, current_m - 1, 1, current_a, current_b, current_p_down, current_l_down, current_m_top, current_i_arrow, current_j_top, current_q)] + current_n + current_o + 1
i += 1
results[key] = r
elif state == 'm_else':
i = 1 - results[(current_n - 1, current_m, current_o, current_a, current_b, current_p_down, current_l_down, current_m_top, current_i_arrow, current_j_top, current_q)]
r = 0
loop_limit = results[(current_n - 1, current_m, current_o, current_a, current_b, current_p_down, current_l_down, current_m_top, current_i_arrow, current_j_top, current_q)] * 3 + current_n + current_m + 1
while i < loop_limit:
r += results[(current_n - 1, current_m, current_o, current_a, current_b, current_p_down, current_l_down, current_m_top, current_i_arrow, current_j_top, current_q)] * 3 + current_n + current_o + 1
i += 1
results[key] = r
# Integrate logic from G function
elif state == 'G_init':
if 0 < current_q = 1:
stack.append((current_n, current_m, current_o, current_a, current_b, current_p_down, current_l_down, current_m_top, current_i_arrow, current_j_top, current_q - 1, 'G_init'))
elif state == 'G_calc':
prev_result = results[key]
resultado = hiperrecursivo(current_p_down, current_l_down, hiperrecursivo(current_m_top, current_i_arrow, current_j_top))
results[key] = resultado
if prev_result != resultado:
stack.append((current_n, current_m, current_o, current_a, current_b, resultado, current_l_down, current_m_top, current_i_arrow, current_j_top, current_q, 'G_init'))
return results[(n, m, o, a, b, p_down, l_down, m_top, i_arrow, j_top, q)]

[@MrKula-0028]

E qual foi o resultado final dessa brincadeira? Cê conseguiu o valor cheio? Vou ver se eu aprendo a mexer nisso aí

[@Daniel91953574]

@@MrKula-0028 evidentemente, se você estiver em duvida porque provavelmente travou quando você testou o F(n,n...) é porque essa estrutura serve apenas para descrevê-lo exatamente, mas os resultados estão em uma magnitude muito alta, como eu disse é uma generalização;

[@Daniel91953574]

@@MrKula-0028 pra função que eu dei, se você acha que dá pra dar um numero pra ele, é porque você não entendeu ela de verdade kkskkk, usei os conceitos de recursão gerada por pilha/stack. Mas se você realmente está interessado explique melhor oque você procura pois 'isso ai' não significa nada?

[@Daniel91953574]

código melhorado pelo claude, mas não achei mais especial pois ele não faz as conversões perfeitas;
import sys
from dataclasses import dataclass
from typing import List, Union, Dict, Optional
from enum import Enum
class NumberType(Enum):
EXACT = 0
EXPONENTIAL_TOWER = 1
HYPER_RECURSIVE = 2
NESTED_ARROW = 3
@dataclass
class LargeNumber:
type: NumberType
value: Union[int, List[int], List[List[int]]]
arrows: Optional[int] = None

def __str__(self):
if self.type == NumberType.EXACT:
return str(self.value)
elif self.type == NumberType.EXPONENTIAL_TOWER:
return f"Tower[{','.join(map(str, self.value))}]"
elif self.type == NumberType.HYPER_RECURSIVE:
return f"Hyper{self.arrows}[{','.join(map(str, self.value))}]"
else:
return f"Arrow{self.arrows}[{','.join(map(str, self.value))}]"
class ComputationStack:
def __init__(self, memory_limit: int = 2048):
self.stack: List[Dict] = []
self.memory_limit = memory_limit
self.results: Dict = {}

def push(self, state: Dict) -> None:
self.stack.append(state)

def pop(self) -> Dict:
return self.stack.pop() if self.stack else None

def peek(self) -> Optional[Dict]:
return self.stack[-1] if self.stack else None

def is_empty(self) -> bool:
return len(self.stack) == 0
def hyper_recursive(a: int, b: int, n: int) -> LargeNumber:
"""Implementa a operação de hiper-operação (notação de seta de Knuth)"""
if n == 0:
return LargeNumber(type=NumberType.EXACT, value=a + b)
if n == 1:
try:
result = pow(a, b)
if len(str(result)) > 2048:
return LargeNumber(
type=NumberType.EXPONENTIAL_TOWER,
value=[a, b]
)
return LargeNumber(type=NumberType.EXACT, value=result)
except OverflowError:
return LargeNumber(
type=NumberType.EXPONENTIAL_TOWER,
value=[a, b]
)

if b == 0:
return LargeNumber(type=NumberType.EXACT, value=1)
if b == 1:
return LargeNumber(type=NumberType.EXACT, value=a)

# Para n ≥ 2 e b ≥ 2, usamos representação de seta
return LargeNumber(
type=NumberType.NESTED_ARROW,
value=[a, b],
arrows=n
)
def evaluate_hyperop_chain(args: List[int], arrows: int) -> LargeNumber:
"""Avalia uma cadeia de hiperoperações"""
if len(args) < 2:
return LargeNumber(type=NumberType.EXACT, value=args[0] if args else 0)

result = hyper_recursive(args[0], args[1], arrows)
for i in range(2, len(args)):
if result.type != NumberType.EXACT:
return LargeNumber(
type=NumberType.NESTED_ARROW,
value=args,
arrows=arrows
)
result = hyper_recursive(result.value, args[i], arrows)

return result
def F(p_down: int, l_down: int, m_top: int, i_arrow: int, j_top: int, q: int) -> LargeNumber:
"""Implementação corrigida da função F usando computação baseada em pilha"""
stack = ComputationStack()

# Estado inicial
state = {
"p_down": p_down,
"l_down": l_down,
"m_top": m_top,
"i_arrow": i_arrow,
"j_top": j_top,
"q": q,
"stage": "INIT",
"sub_results": []
}
stack.push(state)

while not stack.is_empty():
current = stack.peek()

if current["stage"] == "INIT":
if current["q"]

[@juranilcesilva4037]

Muito inyeressante

[@augustowassmann7544]

Onde eu posso aplicar tudo isso na prática?

[@RenataGuimaraesLima]

kkkkkkkkkkkk

[@MrKula-0028]

Ou seja, na heptação de 2 expoente 2 tbm será 4, correto?

[@ioleneSantos-tv2go]

😊😊

[@Marsink2]

Isso já tem alguma aplicação prática?

[@JoseMiguel-te6wc]

Mais uma para a conta

[@souzasilva5471]

Pentação se confunde com a potenciação.

[@zeliamariadeabreu4414]

TETRAÇÃO
³2= 2²²= 2×2×2×2=16

[@zeliamariadeabreu4414]

POTENCIAÇÃO
5³=5×5×5=125

[@vickyk1861]

I got lost after the pentation, thats too much for me

[@zeliamariadeabreu4414]

HEXAÇÃO também não dá

[@lucianohabil]

Com relação ao número dois, além das multiplicações, potenciações, tetração, pentação, hexação, etc, até a soma de dois mais dois são quatro 2+2=4, kkkkkkkkk

[@angelicacintra6993]

Nada conheço sobre o assunto

[@marcelosiqueira4385]

O professor é ótimo! Acredito que esse nível de cálculo tenha aplicação na astrofísica ou em engenharia nuclear. Fiquei curioso sobre a utilidade desse cálculo para fim científico através de programas matemáticos apropriados e em uso em computadores dessas agências espaciais, engenharia de várias áreas de atuação.

[@zeliamariadeabreu4414]

PENTAÇÃO não dá pra representar aqui, só no caderno

[@ElviraLilla-f1p]

Fundo preto é impossível seguir as explicações !

[@flavilense]

PROFESSOR. PORQUE ENTÃO ESTUDADR ESTA HEXAÇÃO? SE NÃO CALCULA