Nossa ! Sem palavras , professor além de vc fazer eu conhecer matérias que nunca ouvi falar , ainda explica bem demais , que domínio e calma para ensinar 👏👏👏👏
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.
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...?
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.
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 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;
@@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?
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 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()
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.
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
Nossa ! Sem palavras , professor além de vc fazer eu conhecer matérias que nunca ouvi falar , ainda explica bem demais , que domínio e calma para ensinar 👏👏👏👏
Amigo,tenho 76 anos,sou professora e estou "arrebentando" em suas aulas que contém novidades...Muito obrigada!!
Excelente!
muio intteressante,essas operações não conhecia.
Pirei nessa! Vou tentar entender!
Gostei bastante da aula,parabéns👏
Excelente trabalho
Muito legal professor, gostei muito dessa aula.
Isso me deu uma tentação para aprender! Parabéns pela ótima explicação!
Pirei nessa. Vou tentar entender.
Vc tem uma ótima didática.
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 .
Amei o vídeo de hoje 👏🏻❤
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.
INTERESANT !
Bom dia professor Silvio Paulo!
Obrigado por mais um maravilhoso vídeo com essa nova operação. Adorei! 17:30 17:30
existe algum uso para essas operações? ou só uma curiosidade matemática?
Ótima pergunta pesquisei no TH-cam não encontrei aplicação dessas operações
Bastante interessante e o que mais impressiona são esses valores astronômicos.
time=16:45 faltou indicar que a soma de 2+2 também é 4
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...?
Aprendi todas essas agora
kkkkkkkkkkkkkkkkkkkk
Vou salvar o vídeo, pois a aula de hoje precisa mais revisão.
I think it also
Noooosssssaaaa! Gigantesco!
Usado em qual área? Hexação essa ferramenta é usado em que?
Obrigado no sabia disso.
Onde eu posso aplicar tudo isso na prática?
kkkkkkkkkkkk
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.
Depois é a Heptação e são infinitas operações
@@vinizin_mathE onde o expoente ficaria na heptação?
@@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. 👍👍
Ou seja, na heptação de 2 expoente 2 tbm será 4, correto?
Isso já tem alguma aplicação prática?
Pentação se confunde com a potenciação.
Muito inyeressante
Mais uma para a conta
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)]
E qual foi o resultado final dessa brincadeira? Cê conseguiu o valor cheio? Vou ver se eu aprendo a mexer nisso aí
@@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;
@@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?
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"]
😊😊
4
2=65536
TETRAÇÃO
³2= 2²²= 2×2×2×2=16
I got lost after the pentation, thats too much for me
POTENCIAÇÃO
5³=5×5×5=125
HEXAÇÃO também não dá
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.
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
Nada conheço sobre o assunto
PENTAÇÃO não dá pra representar aqui, só no caderno
Fundo preto é impossível seguir as explicações !
PROFESSOR. PORQUE ENTÃO ESTUDADR ESTA HEXAÇÃO? SE NÃO CALCULA