zyppe/sagemath
1
0
Fork 0
mirror of https://src.fedoraproject.org/rpms/sagemath.git synced 2025-04-19 02:29:02 -04:00
Code Issues Projects Releases Packages Wiki Activity
sagemath/trac_12822_pt_translation_of_tutorial.patch
pcpa 86f823b2b0 Initial import (#877651).
2013-04-22 14:11:03 -03:00

6801 lines
219 KiB
Diff
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

# HG changeset patch
# User Gustavo de Oliveira <goliveira5d@gmail.com>
# Date 1334006083 -7200
# Node ID ad8e41651a3187a45f087335cb048418bf545506
# Parent bbd101e6eaa8de241270aa8063dc8380a6d983e3
Trac 12822: Portuguese translation of "Tutorial".
diff --git a/doc/pt/tutorial/afterword.rst b/doc/pt/tutorial/afterword.rst
new file mode 100644
--- /dev/null
+++ b/doc/pt/tutorial/afterword.rst
@@ -0,0 +1,181 @@
+********
+Posfacio
+********
+
+Por quê o Python?
+=================
+
+Vantagens do Python
+-------------------
+
+A primeira linguagem de implementação do Sage é o Python (veja [Py]_),
+embora rotinas que precisam ser muito rápidas são implementadas em uma
+linguagem compilada. O Python possui várias vantagens:
+
+- **Salvar objetos** é bem suportado em Python. Existe suporte
+ extenso em Python para salvar (na grande maioria dos casos) objetos
+ arbitrários em arquivos em disco ou em uma base de dados.
+
+- Suporte excelente para **documentação** de funções e pacotes no
+ código fonte, incluindo extração automática de documentação e teste
+ automático de todos os exemplos. Os exemplos são automaticamente
+ testados regularmente para garantir que funcionam como indicado.
+
+- **Gerenciamento de memória:** O Python agora possui um sistema de
+ gerenciamento de memória e "garbage collector" muito bem pensados e
+ robustos que lidam corretamente com referências circulares, e
+ permitem variáveis locais em arquivos.
+
+- O Python possui **diversos pacotes** disponíveis que podem ser de
+ grande interesse para os usuários do Sage: análise numérica e
+ álgebra linear, visualização 2D e 3D, comunicação via rede (para
+ computação distribuída e servidores, por exemplo, via twisted),
+ suporte a base de dados, etc.
+
+- **Portabilidade:** O Python é fácil de compilar a partir do código
+ fonte em poucos minutos na maioria das arquiteturas.
+
+- **Manuseamento de exceções:** O Python possui um sofisticado e bem
+ pensado sistema de manuseamento de exceções, através do qual
+ programas podem facilmente se recuperar mesmo se ocorrerem erros no
+ código que está sendo executado.
+
+- **Debugador:** O Python inclui um debugador, de modo que quando
+ alguma rotina falha por algum motivo, o usuário pode acessar
+ extensiva informação sobre a pilha de cálculos e inspecionar o
+ estado de todas as variáveis relevantes.
+
+- **Profiler:** Existe um profiler para o Python, o qual executa
+ programas e cria um relatório detalhando quantas vezes e por quando
+ tempo cada função foi executada.
+
+- **Uma Linguagem:** Em vez de escrever uma **nova linguagem** para
+ matemática como foi feito para o Magma, Maple, Mathematica, Matlab,
+ GP/PARI, GAP, Macaulay 2, Simath, etc., nós usamos a linguagem
+ Python, que é uma linguagem de programação popular que está
+ sendo desenvolvida e otimizada ativamente por centenas de
+ engenheiros de software qualificados. O Python é uma grande
+ história de sucesso em desenvolvimento com código aberto com um
+ processo de desenvolvimento maduro (veja [PyDev]_).
+
+.. _section-mathannoy:
+
+O Pré-Processador: Diferenças entre o Sage e o Python
+-----------------------------------------------------
+
+Alguns aspectos matemáticos do Python podem ser confusos, logo o Sage
+se comporta diferentemente do Python em diversas situações.
+
+- **Notação para exponenciação:** ``**`` versus ``^``. Em Python,
+ ``^`` significa "xor", não exponenciação, logo em Python temos
+
+ ::
+
+ >>> 2^8
+ 10
+ >>> 3^2
+ 1
+ >>> 3**2
+ 9
+
+ Esse uso de ``^`` pode parecer estranho, e é ineficiente para
+ pesquisa em matemática pura, pois a função "ou exclusivo" é
+ raramente usada. Por conveniência, o Sage pre-processa todos as
+ linhas de comandos antes de passá-las para o Python, substituindo
+ ocorrências de ``^`` que não estão em strings por ``**``:
+
+ ::
+
+ sage: 2^8
+ 256
+ sage: 3^2
+ 9
+ sage: "3^2"
+ '3^2'
+
+- **Divisão por inteiros:** A expressão em Python ``2/3`` não se
+ comporta da forma que um matemático esperaria. Em Python, se ``m``
+ e ``n`` são inteiros (int), então ``m/n`` também é um inteiro
+ (int), a saber, o quociente de ``m`` dividido por ``n``. Portanto
+ ``2/3=0``. Tem havido discussões na comunidade do Python para
+ modificar o Python de modo que ``2/3`` retorne um número de
+ precisão flutuante (float) ``0.6666...``, e ``2//3`` retorne ``0``.
+
+ Nós lidamos com isso no interpretador Sage, encapsulando inteiros
+ literais em ``Integer()`` e fazendo a divisão um construtor para
+ números racionais. Por exemplo:
+
+ ::
+
+ sage: 2/3
+ 2/3
+ sage: (2/3).parent()
+ Rational Field
+ sage: 2//3
+ 0
+ sage: int(2)/int(3)
+ 0
+
+- **Inteiros longos:** O Python possui suporte nativo para inteiros
+ com precisão arbitrária, além de int's do C. Esses são
+ significantemente mais lentos do que os fornecidos pela biblioteca
+ GMP, e têm a propriedade que eles são impressos com o sufixo ``L``
+ para distingui-los de int's (e isso não será modificado no futuro
+ próximo). O Sage implementa inteiros com precisão arbitrária usando
+ a biblioteca C do GMP, e esses são impressos sem o sufixo ``L``.
+
+Em vez de modificar o interpretador Python (como algumas pessoas
+fizeram para projetos internos), nós usamos a linguagem Python
+exatamente com ela é, e escrevemos um pré-processador para o IPython de
+modo que o comportamento da linha de comando seja o que um matemático
+espera. Isso significa que qualquer programa existente em Python pode
+ser usado no Sage. Todavia, deve-se obedecer as regras padrão do
+Python para escrever programas que serão importados no Sage.
+
+(Para instalar uma biblioteca do Python, por exemplo uma que você
+tenha encontrado na internet, siga as instruções, mas execute ``sage
+-python`` em vez de ``python``. Frequentemente isso significa digitar
+``sage -python setup.py install``.)
+
+Eu gostaria de contribuir de alguma forma. Como eu posso?
+=========================================================
+
+Se você quiser contribuir para o Sage, a sua ajuda será muito bem
+vinda! Ela pode variar desde substancial quantidade de código, até
+contribuições com respeito à documentação ou notificação de defeitos
+(bugs).
+
+Explore a página na web do Sage para informações para desenvolvedores;
+entre outras coisas, você pode encontrar uma lista longa de projetos
+relacionados ao Sage ordenados por prioridade e categoria. O `Guia
+para desenvolvedores do Sage
+<http://www.sagemath.org/doc/developer/>`_ (em inglês) também possui
+informações úteis, e você pode também visitar o grupo de discussões
+``sage-devel`` no Google Groups.
+
+Como eu faço referência ao Sage?
+================================
+
+Se você escrever um artigo usando o Sage, por favor faça referência
+aos cálculos feitos com o Sage incluindo
+
+::
+
+ [Sage] William A. Stein et al., Sage Mathematics Software (Version 4.3).
+ The Sage Development Team, 2009, http://www.sagemath.org.
+
+na sua bibliografia (substituindo 4.3 pela versão do Sage que você
+está usando). Além disso, procure observar quais componentes do Sage
+você está usando em seus cálculos, por exemplo, PARI, Singular, GAP,
+Maxima, e também site esses sistemas. Se você está em dúvida sobre
+qual software está sendo usado em seus cálculos, fique à vontade para
+perguntar no grupo ``sage-devel`` do Google Groups. Veja
+:ref:`section-univariate` para mais discussões sobre esse aspecto.
+
+------------
+
+Se por acaso você leu este tutorial do começo ao fim em uma só vez, e
+faz idéia de quanto tempo você levou, por favor nos informe no grupo
+``sage-devel`` do Google Groups.
+
+Divirta-se com o Sage!
diff --git a/doc/pt/tutorial/appendix.rst b/doc/pt/tutorial/appendix.rst
new file mode 100644
--- /dev/null
+++ b/doc/pt/tutorial/appendix.rst
@@ -0,0 +1,33 @@
+********
+Apêndice
+********
+
+.. _section-precedence:
+
+Precedência de operações aritméticas binárias
+=============================================
+
+Quanto é ``3^2*4 + 2%5``? A resposta (38) é determinada pela "tabela
+de precedência" abaixo. A tabela abaixo é baseada na tabela em § 5.14
+do *Python Language Reference Manual* by G. Rossum and F. Drake. As
+operações estão listadas aqui em ordem crescente de precedência.
+
+
+========================== =================
+Operadores Descrição
+========================== =================
+or "ou" booleano
+and "e" booleano
+not "não" booleano
+in, not in pertence
+is, is not teste de identidade
+>, <=, >, >=, ==, !=, <> comparação
++, - adição, subtração
+\*, /, % multiplicação, divisão, resto
+\*\*, ^ exponenciação
+========================== =================
+
+Portanto, para calcular ``3^2*4 + 2%5``, O Sage inclui parenteses de
+precedência da seguinte forma: ``((3^2)*4) + (2%5)``. Logo, primeiro
+calcula ``3^2``, que é ``9``, então calcula ``(3^2)*4`` e ``2%5``, e
+finalmente soma os dois.
diff --git a/doc/pt/tutorial/bibliography.rst b/doc/pt/tutorial/bibliography.rst
new file mode 100644
--- /dev/null
+++ b/doc/pt/tutorial/bibliography.rst
@@ -0,0 +1,52 @@
+************
+Bibliografia
+************
+
+.. [Cyt] Cython, http://www.cython.org.
+
+.. [Dive] Dive into Python, disponível gratuitamente na internet em
+ http://diveintopython.org.
+
+.. [GAP] The GAP Group, GAP - Groups, Algorithms, and
+ Programming, Version 4.4; 2005, http://www.gap-system.org
+
+.. [GAPkg] GAP Packages,
+ http://www.gap-system.org/Packages/packages.html
+
+.. [GP] PARI/GP http://pari.math.u-bordeaux.fr/.
+
+.. [Ip] The IPython shell http://ipython.scipy.org.
+
+.. [Jmol] Jmol: an open-source Java viewer for chemical
+ structures in 3D http://www.jmol.org/.
+
+.. [Mag] Magma http://magma.maths.usyd.edu.au/magma/.
+
+.. [Max] Maxima http://maxima.sf.net/
+
+.. [NagleEtAl2004] Nagle, Saff, and Snider.
+ *Fundamentals of Differential Equations*. 6th edition, Addison-Wesley,
+ 2004.
+
+.. [Py] The Python language http://www.python.org/
+ Reference Manual http://docs.python.org/ref/ref.html.
+
+.. [PyDev] Guido, Some Guys, and a Mailing List: How Python is
+ Developed,
+ http://www.python.org/dev/dev_intro.html.
+
+.. [Pyr] Pyrex,
+ http://www.cosc.canterbury.ac.nz/~greg/python/Pyrex/.
+
+.. [PyT] The Python Tutorial http://www.python.org/.
+
+.. [SA] Sage web site http://www.sagemath.org/.
+
+.. [Si] G.-M. Greuel, G. Pfister, and H. Schönemann. Singular
+ 3.0. A Computer Algebra System for Polynomial Computations. Center
+ for Computer Algebra, University of Kaiserslautern (2005).
+ http://www.singular.uni-kl.de.
+
+.. [SJ] William Stein, David Joyner, Sage: System for Algebra and
+ Geometry Experimentation, Comm. Computer Algebra {39}(2005)61-64.
+
diff --git a/doc/pt/tutorial/conf.py b/doc/pt/tutorial/conf.py
new file mode 100644
--- /dev/null
+++ b/doc/pt/tutorial/conf.py
@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+#
+# Sage documentation build configuration file, based on the file created by
+# sphinx-quickstart on Thu Aug 21 20:15:55 2008.
+#
+# This file is execfile()d with the current directory set to its containing dir.
+#
+# The contents of this file are pickled, so don't put values in the namespace
+# that aren't pickleable (module imports are okay, they're removed automatically).
+#
+# All configuration values have a default; values that are commented out
+# serve to show the default.
+
+import sys, os
+sys.path.append(os.environ['SAGE_DOC'])
+from common.conf import *
+
+# General information about the project.
+project = u"Tutorial Sage"
+name = u'tutorial-pt'
+language = "pt_BR"
+
+# The name for this set of Sphinx documents. If None, it defaults to
+# "<project> v<release> documentation".
+html_title = project + " v"+release
+
+# Output file base name for HTML help builder.
+htmlhelp_basename = name
+
+# Grouping the document tree into LaTeX files. List of tuples
+# (source start file, target name, title, author, document class [howto/manual]).
+latex_documents = [
+ ('index', name+'.tex', project,
+ u'The Sage Group', 'manual'),
+]
diff --git a/doc/pt/tutorial/index.rst b/doc/pt/tutorial/index.rst
new file mode 100644
--- /dev/null
+++ b/doc/pt/tutorial/index.rst
@@ -0,0 +1,46 @@
+.. Sage documentation master file, created by sphinx-quickstart on Thu Aug 21 20:15:55 2008.
+ You can adapt this file completely to your liking, but it should at least
+ contain the root `toctree` directive.
+
+Bem-vindo ao Tutorial Sage!
+===========================
+
+Sage é um software de matemática gratuito, de código aberto, para uso
+em ensino e pesquisa em álgebra, geometria, teoria de números,
+criptografia, computação numérica, e áreas relacionadas. Tanto o
+modelo de desenvolvimento como a tecnologia empregada no Sage se
+distinguem pela forte ênfase em transparência, cooperação, e
+colaboração: estamos desenvolvendo o carro, não reinventando a roda. O
+objetivo maior do Sage é criar uma alternativa viável, gratuita, e de
+código aberto aos programas Maple, Mathematica, Magma e MATLAB.
+
+Este tutorial é a melhor forma de se familiarizar com o Sage em apenas
+algumas horas. Você pode lê-lo em versão HTML ou PDF, ou diretamente
+no Notebook Sage (clique em ``Help``, e então clique em ``Tutorial``
+para percorrer o tutorial de forma iterativa diretamente do Sage).
+
+Este documento está sob a licença `Creative Commons CompartilhaIgual
+3.0`__.
+
+__ http://creativecommons.org/licenses/by-sa/3.0/deed.pt
+
+.. toctree::
+ :maxdepth: 2
+
+ introduction
+ tour
+ interactive_shell
+ interfaces
+ latex
+ programming
+ sagetex
+ afterword
+ appendix
+ bibliography
+
+Índices e tabelas
+=================
+
+* :ref:`genindex`
+* :ref:`modindex`
+* :ref:`search`
diff --git a/doc/pt/tutorial/interactive_shell.rst b/doc/pt/tutorial/interactive_shell.rst
new file mode 100644
--- /dev/null
+++ b/doc/pt/tutorial/interactive_shell.rst
@@ -0,0 +1,1024 @@
+.. _chapter-interactive_shell:
+
+*****************************
+A Linha de Comando Interativa
+*****************************
+Na maior parte deste tutorial, assumimos que você iniciou o
+interpretador Sage usando o comando ``sage``. Isso inicia uma versão
+personalizada da linha de comando IPython, e importa diversas funções
+e classes de modo que elas fiquem prontas para serem usadas a partir
+da linha de comando. Configuração adicional é possível editando o
+arquivo ``$SAGE_ROOT/ipythonrc``. Assim que você inicia o Sage, você
+obtém o seguinte:
+
+.. skip
+
+::
+
+ ----------------------------------------------------------------------
+ | SAGE Version 3.1.1, Release Date: 2008-05-24 |
+ | Type notebook() for the GUI, and license() for information. |
+ ----------------------------------------------------------------------
+ sage:
+
+Para sair do Sage pressione Ctrl-D ou digite ``quit`` ou ``exit``.
+
+.. skip
+
+::
+
+ sage: quit
+ Exiting SAGE (CPU time 0m0.00s, Wall time 0m0.89s)
+
+O wall time é o tempo que passou no relógio "pendurado na sua parede".
+Isso é relevante, pois o tempo CPU não conta o tempo usado por
+subprocessos como GAP ou Singular.
+
+(Evite terminar um processo do Sage usando ``kill -9`` a partir de um
+terminal, pois o Sage pode não terminal seus subprocessos, por
+exemplo, subprocessos do Maple, ou limpeza de arquivos temporários em
+``$HOME/.sage/tmp``.)
+
+A Sua Sessão no Sage
+====================
+
+A sessão é a sequência de entradas e saídas de dados desde o momento em
+que você inicia até o momento em que você termina o Sage. O Sage grava
+todas as entradas de dados, através do IPython. De fato, se você está
+usando a linha de comando (não o Notebook), então a qualquer momento
+você pode digitar ``%history`` (ou ``%hist``) para obter uma lista de
+todas as linhas digitadas até então. Você pode digitar ``?`` no prompt
+do Sage para aprender mais sobre o IPython, por exemplo, "IPython
+offers numbered prompts ... with input and output caching. All input
+is saved and can be retrieved as variables (besides the usual arrow
+key recall). The following GLOBAL variables always exist (so don't
+overwrite them!)":
+
+::
+
+ _: previous input (interactive shell and notebook)
+ __: next previous input (interactive shell only)
+ _oh : list of all inputs (interactive shell only)
+
+Aqui vai um exemplo:
+
+.. skip
+
+::
+
+ sage: factor(100)
+ _1 = 2^2 * 5^2
+ sage: kronecker_symbol(3,5)
+ _2 = -1
+ sage: %hist #This only works from the interactive shell, not the notebook.
+ 1: factor(100)
+ 2: kronecker_symbol(3,5)
+ 3: %hist
+ sage: _oh
+ _4 = {1: 2^2 * 5^2, 2: -1}
+ sage: _i1
+ _5 = 'factor(ZZ(100))\n'
+ sage: eval(_i1)
+ _6 = 2^2 * 5^2
+ sage: %hist
+ 1: factor(100)
+ 2: kronecker_symbol(3,5)
+ 3: %hist
+ 4: _oh
+ 5: _i1
+ 6: eval(_i1)
+ 7: %hist
+
+Vamos omitir a numeração das linhas no restante deste tutorial e em
+outras documentações do Sage.
+
+Você também pode salvar uma lista de comandos em uma macro.
+
+.. skip
+
+::
+
+ sage: E = EllipticCurve([1,2,3,4,5])
+ sage: M = ModularSymbols(37)
+ sage: %hist
+ 1: E = EllipticCurve([1,2,3,4,5])
+ 2: M = ModularSymbols(37)
+ 3: %hist
+ sage: %macro em 1-2
+ Macro `em` created. To execute, type its name (without quotes).
+
+
+.. skip
+
+::
+
+ sage: E
+ Elliptic Curve defined by y^2 + x*y + 3*y = x^3 + 2*x^2 + 4*x + 5 over
+ Rational Field
+ sage: E = 5
+ sage: M = None
+ sage: em
+ Executing Macro...
+ sage: E
+ Elliptic Curve defined by y^2 + x*y + 3*y = x^3 + 2*x^2 + 4*x + 5 over
+ Rational Field
+
+Quando se usa a linha de comando, qualquer comando UNIX pode ser
+executado a partir do Sage inserindo um ponto de exclamação ``!`` como
+prefixo. Por exemplo,
+
+.. skip
+
+::
+
+ sage: !ls
+ auto example.sage glossary.tex t tmp tut.log tut.tex
+
+fornece a lista de arquivos do atual diretório.
+
+O ``PATH`` possui o diretório bin do Sage em primeiro, portanto se
+você digitar ``p``, ``gap``, ``singular``, ``maxima``, etc., você
+executa a versão incluída no Sage.
+
+.. skip
+
+::
+
+ sage: !gp
+ Reading GPRC: /etc/gprc ...Done.
+
+ GP/PARI CALCULATOR Version 2.2.11 (alpha)
+ i686 running linux (ix86/GMP-4.1.4 kernel) 32-bit version
+ ...
+ sage: !singular
+ SINGULAR / Development
+ A Computer Algebra System for Polynomial Computations / version 3-0-1
+ 0<
+ by: G.-M. Greuel, G. Pfister, H. Schoenemann \ October 2005
+ FB Mathematik der Universitaet, D-67653 Kaiserslautern \
+
+Gravando Entradas e Saídas de dados
+===================================
+
+Gravar a sua sessão no Sage não é o mesmo que salvá-la (veja
+:ref:`section-save`). Para gravar a entrada de dados (e opcionalmente
+a saída) use o comando ``logstart``. Digite ``logstart?`` para mais
+detalhes. Você pode usar esse comando para gravar tudo o que você
+digita, toda a saída de dados, e até mesmo usar essa entrada de dados
+que você guardou em uma sessão futura (simplesmente importando o
+arquivo log).
+
+.. skip
+
+::
+
+ was@form:~$ sage
+ ----------------------------------------------------------------------
+ | SAGE Version 3.0.2, Release Date: 2008-05-24 |
+ | Type notebook() for the GUI, and license() for information. |
+ ----------------------------------------------------------------------
+
+ sage: logstart setup
+ Activating auto-logging. Current session state plus future input saved.
+ Filename : setup
+ Mode : backup
+ Output logging : False
+ Timestamping : False
+ State : active
+ sage: E = EllipticCurve([1,2,3,4,5]).minimal_model()
+ sage: F = QQ^3
+ sage: x,y = QQ['x,y'].gens()
+ sage: G = E.gens()
+ sage:
+ Exiting SAGE (CPU time 0m0.61s, Wall time 0m50.39s).
+ was@form:~$ sage
+ ----------------------------------------------------------------------
+ | SAGE Version 3.0.2, Release Date: 2008-05-24 |
+ | Type notebook() for the GUI, and license() for information. |
+ ----------------------------------------------------------------------
+
+ sage: load "setup"
+ Loading log file <setup> one line at a time...
+ Finished replaying log file <setup>
+ sage: E
+ Elliptic Curve defined by y^2 + x*y = x^3 - x^2 + 4*x + 3 over Rational
+ Field
+ sage: x*y
+ x*y
+ sage: G
+ [(2 : 3 : 1)]
+
+Se você usa o Sage no terminal ``konsole`` do Linux KDE, então você
+pode gravar a sessão da seguinte forma: após iniciar o Sage no
+``konsole``, selecione "settings", então "history...", então "set
+unlimited". Quando você estiver pronto para guardar a sua sessão,
+selecione "edit" e então "save history as..." e digite um nome para
+salvar o texto de sua sessão em seu computador. Após salvar esse
+arquivo, você poderia abri-lô em um editor, tal como o xemacs, e
+imprimi-lo.
+
+Colar Texto Ignora Prompts
+==========================
+
+Suponha que você está lendo uma sequência de comandos em Sage ou
+Python e quer copiá-los no Sage. Mas eles têm os irritantes prompts
+``>>>`` ou ``sage:`` para te aborrecer. De fato, você pode copiar e
+colar um exemplo, incluindo os prompts se você quiser, no Sage. Em
+outras palavras, automaticamente o Sage remove os caracteres ``>>>``
+ou ``sage:`` antes de colar o conteúdo no Python. Por exemplo,
+
+.. skip
+
+::
+
+ sage: 2^10
+ 1024
+ sage: sage: sage: 2^10
+ 1024
+ sage: >>> 2^10
+ 1024
+
+Comandos de Tempo
+=================
+
+Se você colocar o comando ``%time`` no começo de uma linha de comando,
+o tempo que o comando leva para ser executado vai aparecer após a
+saída de dados. Por exemplo, nós podemos comparar o tempo de execução
+para certas operações de exponenciação de várias formas. Os tempos
+abaixo vão ser provavelmente muito diferentes para o seu computador,
+ou até mesmo para versões diferentes do Sage. Primeiro, usando o
+Python
+
+.. skip
+
+::
+
+ sage: %time a = int(1938)^int(99484)
+ CPU times: user 0.66 s, sys: 0.00 s, total: 0.66 s
+ Wall time: 0.66
+
+Isso significa que levou 0.66 segundos no total, e o wall time, isto
+é, a quantidade de tempo que passou no seu relógio de parede, é também
+0.66 segundos. Se o seu computador está executado outros programas o
+wall time pode ser muito maior do que o tempo de CPU.
+
+A seguir verificamos o tempo de exponenciação usando o tipo Integer do
+Sage, o qual é implementado (em Cython) usando a biblioteca GMP:
+
+.. skip
+
+::
+
+ sage: %time a = 1938^99484
+ CPU times: user 0.04 s, sys: 0.00 s, total: 0.04 s
+ Wall time: 0.04
+
+Usando a biblioteca C do PARI:
+
+.. skip
+
+::
+
+ sage: %time a = pari(1938)^pari(99484)
+ CPU times: user 0.05 s, sys: 0.00 s, total: 0.05 s
+ Wall time: 0.05
+
+A GMP é melhor, mas por pouco (como esperado, pois a versão do PARI
+contida no Sage usa a GMP para aritmética de inteiros).
+
+Você pode também contar o tempo de um bloco de comandos usado o
+comando ``cputime``, como ilustrado abaixo:
+
+::
+
+ sage: t = cputime()
+ sage: a = int(1938)^int(99484)
+ sage: b = 1938^99484
+ sage: c = pari(1938)^pari(99484)
+ sage: cputime(t) # somewhat random output
+ 0.64
+
+.. skip
+
+::
+
+ sage: cputime?
+ ...
+ Return the time in CPU second since SAGE started, or with optional
+ argument t, return the time since time t.
+ INPUT:
+ t -- (optional) float, time in CPU seconds
+ OUTPUT:
+ float -- time in CPU seconds
+
+O comando ``walltime`` se comporta como o comando ``cputime``, exceto
+que ele conta o tempo do relógio.
+
+Nós podemos também calcular a potência acima em alguns softwares de
+álgebra incluídos no Sage. Em cada caso executamos um comando trivial
+no sistema de modo a inicializar o servidor para aquele programa. O
+tempo mais relevante é o tempo do relógio. Todavia, se houver uma
+diferença significativa entre o wall time e o CPU time então isso pode
+indicar algum problema de performance que vale a pena investigar.
+
+.. skip
+
+::
+
+ sage: time 1938^99484;
+ CPU times: user 0.01 s, sys: 0.00 s, total: 0.01 s
+ Wall time: 0.01
+ sage: gp(0)
+ 0
+ sage: time g = gp('1938^99484')
+ CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
+ Wall time: 0.04
+ sage: maxima(0)
+ 0
+ sage: time g = maxima('1938^99484')
+ CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
+ Wall time: 0.30
+ sage: kash(0)
+ 0
+ sage: time g = kash('1938^99484')
+ CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
+ Wall time: 0.04
+ sage: mathematica(0)
+ 0
+ sage: time g = mathematica('1938^99484')
+ CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
+ Wall time: 0.03
+ sage: maple(0)
+ 0
+ sage: time g = maple('1938^99484')
+ CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
+ Wall time: 0.11
+ sage: gap(0)
+ 0
+ sage: time g = gap.eval('1938^99484;;')
+ CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
+ Wall time: 1.02
+
+Note que o GAP e o Maxima são os mais lentos neste teste (isso foi
+executado no computador ``sage.math.washington.edu``). Devido ao
+"overhead" da interface pexpect, talvez não seja apropriado comparar
+esses resultados com o Sage, que é o mais rápido.
+
+Outras Dicas para o IPython
+===========================
+
+Como observado acima, o Sage usa o IPython como interface, logo você
+pode usar quaisquer comandos e recursos do IPython. Você pode ler a
+`Documentação completa do IPython
+<http://ipython.scipy.org/moin/Documentation>`_ (em inglês).
+
+- Você pode usar ``%bg`` para executar um comando no background, e
+ então usar ``jobs`` para acessar os resultados, da seguinte forma.
+ (Os comentários ``not tested`` estão aqui porque a sintaxe ``%bg``
+ não funciona bem com o sistema de testes automáticos do Sage. Se
+ você digitar esses comandos, eles devem funcionar. Isso é obviamente
+ mais útil com comandos que demoram para serem completados.)
+
+ ::
+
+ sage: def quick(m): return 2*m
+ sage: %bg quick(20) # not tested
+ Starting job # 0 in a separate thread.
+ sage: jobs.status() # not tested
+ Completed jobs:
+ 0 : quick(20)
+ sage: jobs[0].result # the actual answer, not tested
+ 40
+
+ Note que os comandos executados no background não usam o
+ pre-processador (preparser) do Sage -- veja :ref:`section-mathannoy`
+ para mais informações. Uma forma (estranha talvez) de contornar esse
+ problema seria executar ::
+
+ sage: %bg eval(preparse('quick(20)')) # not tested
+
+ É mais seguro e simples, todavia, usar ``%bg`` apenas em comandos
+ que não requerem o pre-processador (preparser).
+
+- Você pode usar ``%edit`` (ou ``%ed`` ou ``ed``) para abrir um
+ editor, se você desejar digitar algum código mais complexo. Antes de
+ iniciar o Sage, certifique-se de que a variável de environment
+ :envvar:`EDITOR` está definida com o seu editor favorito (colocando
+ ``export EDITOR=/usr/bin/emacs`` ou ``export EDITOR=/usr/bin/vim``
+ or algo similar no lugar apropriado, como um arquivo ``.profile``).
+ A partir do prompt do Sage, o comando ``%edit`` irá abrir o editor
+ escolhido. Então usando o editor você pode definir uma função::
+
+ def some_function(n):
+ return n**2 + 3*n + 2
+
+ Salve e feche o editor. No restante da sua sessão do Sage, você pode
+ usar então a função ``some_function``. Se você quiser modificá-la,
+ digite ``%edit some_function`` no prompt do Sage.
+
+- Se você for calcular algo e quiser modificar o resultado para outro
+ uso, execute o cálculo e então digite ``%rep``: isso irá colocar o
+ resultado do comando anterior no prompt do Sage, pronto para ser
+ editado.::
+
+ sage: f(x) = cos(x)
+ sage: f(x).derivative(x)
+ -sin(x)
+
+ A esta altura, se você digitar ``%rep`` no prompt do Sage, você irá
+ obter um novo prompt, seguido de ``-sin(x)``, com o cursor no final
+ da linha.
+
+Para mais informações, digite ``%quickref`` para ver um guia rápido de
+referência do IPython. Quando este tutorial foi escrito (April 2011),
+o Sage usa a versão 0.9.1 do IPython, e a `documentation for its magic
+commands <http://ipython.scipy.org/doc/rel-0.9.1/html/interactive/reference.html#magic-commands>`_
+está disponível na internet.
+
+
+Erros e Exceções
+================
+
+Quando algo errado ocorre, você usualmente verá uma "exceção" do
+Python. O Python até mesmo tenta sugerir o que ocasionou a exceção,
+por exemplo, ``NameError`` ou ``ValueError`` (veja o Manual de
+Referência do Python [Py]_ para uma lista completa de exceções). Por
+exemplo,
+
+.. skip
+
+::
+
+ sage: 3_2
+ ------------------------------------------------------------
+ File "<console>", line 1
+ ZZ(3)_2
+ ^
+ SyntaxError: invalid syntax
+
+ sage: EllipticCurve([0,infinity])
+ ------------------------------------------------------------
+ Traceback (most recent call last):
+ ...
+ TypeError: Unable to coerce Infinity (<class 'sage...Infinity'>) to Rational
+
+O debugador interativo é as vezes útil para entender o que houve de
+errado. Você pode ativá-lo e desativá-lo usando ``%pdb`` (o padrão é
+desativado). O prompt ``ipdb>`` aparece se uma exceção é levantada e o
+debugador está ativado. A partir do debugador, você pode imprimir o
+estado de qualquer variável local, e mover a pilha de execução para
+cima e para baixo. Por exemplo,
+
+.. skip
+
+::
+
+ sage: %pdb
+ Automatic pdb calling has been turned ON
+ sage: EllipticCurve([1,infinity])
+ ---------------------------------------------------------------------------
+ <type 'exceptions.TypeError'> Traceback (most recent call last)
+ ...
+
+ ipdb>
+
+Para uma lista de comandos do debugador, digite ``?`` no prompt
+``ipbd>``:
+
+::
+
+ ipdb> ?
+
+ Documented commands (type help <topic>):
+ ========================================
+ EOF break commands debug h l pdef quit tbreak
+ a bt condition disable help list pdoc r u
+ alias c cont down ignore n pinfo return unalias
+ args cl continue enable j next pp s up
+ b clear d exit jump p q step w
+ whatis where
+
+ Miscellaneous help topics:
+ ==========================
+ exec pdb
+
+ Undocumented commands:
+ ======================
+ retval rv
+
+Digite Ctrl-D ou ``quit`` para retornar ao Sage.
+
+.. _section-tabcompletion:
+
+Busca Reversa e Completamento Tab
+==================================
+
+Busca reversa: Digite o começo de um comando, e então ``Ctrl-p`` (ou
+tecle a seta para cima) para voltar para cada linha que você digitou
+que começa daquela forma. Isso funciona mesmo se você encerrou o Sage
+e iniciou novamente mais tarde. Você também pode fazer uma busca
+reversa ao longo da história usando ``Ctrl-r``. Todos esses recursos
+usam o pacote ``readline``, que está disponível no Linux.
+
+Para ilustrar a busca reversa, primeiro crie o e espaço vetorial
+tri-dimensional :math:`V=\QQ^3` da seguinte forma:
+
+::
+
+ sage: V = VectorSpace(QQ,3)
+ sage: V
+ Vector space of dimension 3 over Rational Field
+
+Você pode usar a seguinte notação mais compacta:
+
+::
+
+ sage: V = QQ^3
+
+Então é fácil listar todas as funções para :math:`V` usando
+completamento. Digite ``V``, e então pressione a tecla ``[tab]`` no
+seu teclado:
+
+.. skip
+
+::
+
+ sage: V.[tab key]
+ V._VectorSpace_generic__base_field
+ ...
+ V.ambient_space
+ V.base_field
+ V.base_ring
+ V.basis
+ V.coordinates
+ ...
+ V.zero_vector
+
+Se você digitar as primeiras letras de uma função, e então a tecla
+``[tab]``, você obtém apenas funções que começam conforme indicado.
+
+.. skip
+
+::
+
+ sage: V.i[tab key]
+ V.is_ambient V.is_dense V.is_full V.is_sparse
+
+Se você gostaria de saber o que uma função faz, por exemplo, a função
+coordinates, digite ``V.coordinates?`` para ajuda ou
+``V.coordinates??`` para ver o código fonte, como explicado na próxima
+sessão.
+
+
+
+Sistema de Ajuda Integrado
+==========================
+
+O Sage possui um sistema de ajuda integrado. Digite o nome da função
+seguido de ? para ver informações sobre a função.
+
+.. skip
+
+::
+
+ sage: V = QQ^3
+ sage: V.coordinates?
+ Type: instancemethod
+ Base Class: <type 'instancemethod'>
+ String Form: <bound method FreeModule_ambient_field.coordinates of Vector
+ space of dimension 3 over Rational Field>
+ Namespace: Interactive
+ File: /home/was/s/local/lib/python2.4/site-packages/sage/modules/f
+ ree_module.py
+ Definition: V.coordinates(self, v)
+ Docstring:
+ Write v in terms of the basis for self.
+
+ Returns a list c such that if B is the basis for self, then
+
+ sum c_i B_i = v.
+
+ If v is not in self, raises an ArithmeticError exception.
+
+ EXAMPLES:
+ sage: M = FreeModule(IntegerRing(), 2); M0,M1=M.gens()
+ sage: W = M.submodule([M0 + M1, M0 - 2*M1])
+ sage: W.coordinates(2*M0-M1)
+ [2, -1]
+
+Como mostrado acima, o comando de ajuda mostra o tipo do objeto, o
+arquivo no qual ele é definido, e uma descrição útil da função com
+exemplos que você pode colar na sua sessão atual. Quase todos esses
+exemplos são regularmente testados automaticamente para certificar que
+eles se comportam exatamente como esperado.
+
+Outro recurso que vai muito na direção do espírito de código aberto do
+Sage é que se ``f`` é uma função do Python, então o comando ``f??``
+mostra o código fonte que define ``f``. Por exemplo,
+
+.. skip
+
+::
+
+ sage: V = QQ^3
+ sage: V.coordinates??
+ Type: instancemethod
+ ...
+ Source:
+ def coordinates(self, v):
+ """
+ Write $v$ in terms of the basis for self.
+ ...
+ """
+ return self.coordinate_vector(v).list()
+
+Isso nos diz que tudo que a função ``coordinates`` faz é chamar a
+função ``coordinate_vector`` e converter o resultado para uma lista. O
+que a função ``coordinate_vector`` faz?
+
+.. skip
+
+::
+
+ sage: V = QQ^3
+ sage: V.coordinate_vector??
+ ...
+ def coordinate_vector(self, v):
+ ...
+ return self.ambient_vector_space()(v)
+
+A função ``coordinate_vector`` coage a sua entrada em um espaço
+ambiente, o que tem o efeito de calcular o vetor de coeficientes de
+:math:`v` em termos de :math:`V`. O espaço :math:`V` já é o espaço
+ambiente pois é simplesmente :math:`\QQ^3`. Existe também uma função
+``coordinate_vector`` para subespaços, que é diferente. Vamos criar um
+subespaço e ver:
+
+.. skip
+
+::
+
+ sage: V = QQ^3; W = V.span_of_basis([V.0, V.1])
+ sage: W.coordinate_vector??
+ ...
+ def coordinate_vector(self, v):
+ """
+ ...
+ """
+ # First find the coordinates of v wrt echelon basis.
+ w = self.echelon_coordinate_vector(v)
+ # Next use transformation matrix from echelon basis to
+ # user basis.
+ T = self.echelon_to_user_matrix()
+ return T.linear_combination_of_rows(w)
+
+(Se você acha que a implementação é ineficiente, por favor junte-se a
+nós para ajudar a optimizar as funções de álgebra linear.)
+
+Você também pode digitar ``help(command_name)`` ou ``help(class)``
+para ler um arquivo de ajuda sobre determinada classe.
+
+.. skip
+
+::
+
+ sage: help(VectorSpace)
+ Help on class VectorSpace ...
+
+ class VectorSpace(__builtin__.object)
+ | Create a Vector Space.
+ |
+ | To create an ambient space over a field with given dimension
+ | using the calling syntax ...
+ :
+ :
+
+Quando você digita ``q`` para sair do sistema de ajuda, a sua sessão
+aparece na tela da mesma forma que anteriormente. O texto de ajuda não
+fica permanentemente em sua tela, ao contrário da saída de
+``function_name?`` que as vezes fica. É partircularmente útil digitar
+``help(module_name)``. Por exemplo, espaços vetoriais são definidos em
+``sage.modules.free_module``, então digite
+``help(sage.modules.free_module)`` para obter documentação sobre esse
+módulo. Quando visualizando documentação usando a ajuda, você pode
+procurar no texto digitando ``/`` e na ordem reversa digitando ``?``.
+
+Salvando e Carregando Objetos Individuais
+=========================================
+
+Suponha que você calcule uma matriz, ou pior ainda, um espaço
+complicado de símbolos, e gostaria de salvá-los para uso posterior. O
+que você pode fazer? Existem várias estratégias que os sistemas
+computacionais de álgebra adotam para salvar objetos individuais.
+
+#. **Salve seus cálculos:** Suportam apenas salvar e carregar uma
+ sessão completa (por exemplo, GAP, Magma).
+
+#. **Entrada e Saída Unificadas:** Faz com que cada objeto seja
+ impresso de uma forma que possa ser lido novamente (GP/PARI).
+
+#. **Eval:** Torna fácil processar um código arbitrário no
+ interpretador (por exemplo, Singular, PARI).
+
+
+
+Como o Sage usa o Python, ele adota uma estratégia diferente, que se
+baseia no fato de que qualquer objeto pode ser "serializado", isto é,
+transformado em uma string a partir da qual o objeto pode ser
+recuperado. Isso segue o espírito da estratégia unificada de entrada e
+saída do PARI, exceto que não possue a desvantagem que os objetos são
+impressos na tela em uma forma muito complicada. Além disso, o suporte
+para salvar e recuperar é (na maior parte dos casos) completamente
+automática, não requerendo nenhuma programação extra; é simplesmente um
+recurso do Python que foi implementado na linguagem desde o início de
+seu desenvolvimento.
+
+Quase todos os objetos ``x`` podem ser armazenados em disco de forma
+comprimida usando ``save(x, filename)`` (ou em muitos casos
+``x.save(filename)``). Para carregar o objeto de volta no Sage use
+``load(filename)``.
+
+.. skip
+
+::
+
+ sage: A = MatrixSpace(QQ,3)(range(9))^2
+ sage: A
+ [ 15 18 21]
+ [ 42 54 66]
+ [ 69 90 111]
+ sage: save(A, 'A')
+
+Você deve agora sair do Sage e reiniciá-lo. Então você pode obter
+``A`` de volta:
+
+.. skip
+
+::
+
+ sage: A = load('A')
+ sage: A
+ [ 15 18 21]
+ [ 42 54 66]
+ [ 69 90 111]
+
+Você pode fazer o mesmo com objetos mais complicados, por exemplo,
+curvas elípticas. Todos os dados sobre o objeto são guardados e
+restaurados com o objeto. Por exemplo,
+
+.. skip
+
+::
+
+ sage: E = EllipticCurve('11a')
+ sage: v = E.anlist(100000) # takes a while
+ sage: save(E, 'E')
+ sage: quit
+
+A versão em disco de ``E`` ocupa 153 kilobytes, pois ela guarda os
+primeiros 1000000 :math:`a_n` com ela.
+
+.. skip
+
+::
+
+ ~/tmp$ ls -l E.sobj
+ -rw-r--r-- 1 was was 153500 2006-01-28 19:23 E.sobj
+ ~/tmp$ sage [...]
+ sage: E = load('E')
+ sage: v = E.anlist(100000) # instant!
+
+(Em Python, salvar e restaurar é feito usando o módulo ``cPickle``. Em
+particular, um objeto ``x`` do Sage pode ser salvado usando
+``cPickle.dumps(x, 2)``. Note o ``2``!)
+
+O sage não pode salvar e carregar objetos criados em algum outro
+sistema computacional de álgebra, por exemplo, GAP, Singular, Maxima,
+etc. Eles são carregados em um estado "inválido". Em GAP, embora
+muitos objetos podem ser impressos de uma forma que eles podem ser
+reconstruídos, muitos não, logo reconstrução a partir de suas
+representações impressas não é permitido.
+
+.. skip
+
+::
+
+ sage: a = gap(2)
+ sage: a.save('a')
+ sage: load('a')
+ Traceback (most recent call last):
+ ...
+ ValueError: The session in which this object was defined is no longer
+ running.
+
+Objetos do GP/PARI também podem ser salvados e carregados pois suas
+representações em forma impressa são suficientes para reconstruí-los.
+
+.. skip
+
+::
+
+ sage: a = gp(2)
+ sage: a.save('a')
+ sage: load('a')
+ 2
+
+Objetos que foram salvados podem ser abertos posteriormente em
+computadores com arquiteturas e sistemas operacionais diferentes, por
+exemplo, você poderia salvar uma matriz muito grande em um OS X de
+32-bits e abri-lo em um Linux de 64-bits, encontrar a forma reduzida,
+e movê-lo de volta. Além disso, em muitos casos você pode até mesmo
+abrir objetos em versões do Sage diferentes daquela no qual o objeto
+foi salvo, desde que o código para aquele objeto não seja muito
+diferente. Todos os atributos do objetos são armazendos, assim como a
+classe (mas não o código fonte) que define o objeto. Se aquela classe
+não existir mais em uma nova versão do Sage, então o objeto não pode
+ser reaberto nessa versão. Mas você poderia abri-lo em uma versão mais
+antiga, obter o dicionário do objeto (com ``x.__dict__``), salvar o
+dicionário, e abri-lo em uma versão mais nova.
+
+Salvando como Texto
+-------------------
+
+Você também pode salvar a representação em texto (ASCII) de objetos em
+um arquivo, simplesmente abrindo um arquivo em modo de escrita, e
+escrevendo a string que representa o objeto no arquivo (você pode
+salvar mais de um objeto dessa forma). Quando você terminar de
+escrever os objetos, feche o arquivo.
+
+.. skip
+
+::
+
+ sage: R.<x,y> = PolynomialRing(QQ,2)
+ sage: f = (x+y)^7
+ sage: o = open('file.txt','w')
+ sage: o.write(str(f))
+ sage: o.close()
+
+.. _section-save:
+
+Salvando e Abrindo Sessões Completas
+====================================
+
+O Sage é flexível para salvar e abrir sessões completas.
+
+O comando ``save_session(sessionname)`` salva todas as variáveis que
+você definiu na sessão atual como um dicionário com o nome
+``sessionname``. (No caso raro de uma variável não poder ser salva,
+ela simplesmente não aparece no dicionário.) O resultado é um arquivo
+``.sobj`` que pode ser aberto como qualquer outro objeto que foi
+salvado. Quando você abre os objetos que foram salvados em uma sessão,
+você obtém um dicionário cujas chaves (keys) são os nomes das
+variáveis e os valores são os objetos.
+
+Você pode usar o comando ``load_session(sessionname)`` para carregar
+na presente sessão as variáveis definidas em ``sessioname``. Note que
+isso não remove as variáveis já definidas na presente sessão; em vez
+disso, as duas sessões são combinadas.
+
+Primeiro iniciamos o Sage e definimos algumas variáveis.
+
+.. skip
+
+::
+
+ sage: E = EllipticCurve('11a')
+ sage: M = ModularSymbols(37)
+ sage: a = 389
+ sage: t = M.T(2003).matrix(); t.charpoly().factor()
+ _4 = (x - 2004) * (x - 12)^2 * (x + 54)^2
+
+A seguir nós salvamos a nossa sessão, o que armazena cada uma das
+variáveis acima em um arquivo. Então visualizamos o arquivo, que tem
+por volta de 3K bytes.
+
+.. skip
+
+::
+
+ sage: save_session('misc')
+ Saving a
+ Saving M
+ Saving t
+ Saving E
+ sage: quit
+ was@form:~/tmp$ ls -l misc.sobj
+ -rw-r--r-- 1 was was 2979 2006-01-28 19:47 misc.sobj
+
+Por fim reiniciamos o Sage, definimos algumas variáveis extra, e
+carregamos a sessão que foi salva anteriormente.
+
+.. skip
+
+::
+
+ sage: b = 19
+ sage: load_session('misc')
+ Loading a
+ Loading M
+ Loading E
+ Loading t
+
+Cada variável que foi salva está de novo disponível. Além disso, a
+variável ``b`` não foi redefinida.
+
+.. skip
+
+::
+
+ sage: M
+ Full Modular Symbols space for Gamma_0(37) of weight 2 with sign 0
+ and dimension 5 over Rational Field
+ sage: E
+ Elliptic Curve defined by y^2 + y = x^3 - x^2 - 10*x - 20 over Rational
+ Field
+ sage: b
+ 19
+ sage: a
+ 389
+
+
+
+.. _section-notebook:
+
+A Interface do Notebook
+=======================
+
+O Sage Notebook é iniciado digitando
+
+.. skip
+
+::
+
+ sage: notebook()
+
+na linha de comando do Sage. Isso inicia o Notebook e abre o seu
+browser padrão para visualizá-lo. Os arquivos de estado do servidor
+são armazenados em ``$HOME/.sage/sage\_notebook``.
+
+Outras opções incluem:
+
+.. skip
+
+::
+
+ sage: notebook("directory")
+
+a qual inicia um novo servidor para o Notebook usando arquivos em um
+dado diretório, em vez do diretório padrão
+``$HOME/.sage/sage_notebook``. Isso pode ser útil se você quiser ter
+uma coleção de folhas de trabalho (worksheets) associadas com um
+projeto específico, ou executar vários Notebooks separadamente ao
+mesmo tempo.
+
+Quando você inicia o Notebook, ele primeiro cria os seguintes arquivos
+em ``$HOME/.sage/sage_notebook``:
+
+::
+
+ nb.sobj (the notebook SAGE object file)
+ objects/ (a directory containing SAGE objects)
+ worksheets/ (a directory containing SAGE worksheets).
+
+Após criar os arquivos acima, o Notebook inicia o servidor web.
+
+Um "Notebook" é uma coleção de contas de usuário, cada qual pode ter
+várias folhas de trabalho (worksheets). Quando você cria uma nova
+folha de trabalho, os dados dela são armazenados no diretórios
+``worksheets/username/number``. Em cada diretório desse há um arquivo
+texto ``worksheet.txt`` - se algum problema ocorrer com as suas
+folhas de trabalho, ou com o Sage, esse arquivo texto contém toda
+informação necessária para reconstruir a folha de trabalho.
+
+A partir do Sage, digite ``notebook?`` para mais informações sobre
+como iniciar um servidor.
+
+O seguinte diagrama ilustra a arquitetura do Notebook Sage:
+
+::
+
+ ----------------------
+ | |
+ | |
+ | firefox/safari |
+ | |
+ | javascript |
+ | program |
+ | |
+ | |
+ ----------------------
+ | ^
+ | AJAX |
+ V |
+ ----------------------
+ | |
+ | sage | SAGE process 1
+ | web | ------------> SAGE process 2 (Python processes)
+ | server | pexpect SAGE process 3
+ | | .
+ | | .
+ ---------------------- .
+
+Para ajuda sobre as teclas de atalho disponíveis no Notebook, clique
+no link ``Help``.
diff --git a/doc/pt/tutorial/interfaces.rst b/doc/pt/tutorial/interfaces.rst
new file mode 100644
--- /dev/null
+++ b/doc/pt/tutorial/interfaces.rst
@@ -0,0 +1,341 @@
+.. linkall
+
+**********
+Interfaces
+**********
+
+Uma característica central do Sage é que ele permite fazer cálculos
+com objetos em vários sistemas de álgebra computacional usando uma
+interface comum e uma linguagem de programação clara.
+
+Os métodos console e interact de uma interface executam tarefas bem
+diferentes. Por exemplo, usando GAP:
+
+#. ``gap.console()``: Isso abre um console do GAP - o controle é
+ transferido para o GAP. Aqui o Sage não é nada mais do que uma
+ forma conveniente de executar um programa, similar à shell Bash do
+ Linux.
+
+#. ``gap.interact()``: Essa é uma forma de interagir com uma instância
+ do GAP que pode estar cheia de objetos do Sage. Você pode
+ importar objetos nessa seção do GAP (até mesmo a partir da
+ interface interativa), etc.
+
+
+.. index: PARI; GP
+
+GP/PARI
+=======
+
+O PARI é um programa em C muito compacto, maduro, e extremamente
+otimizado cujo foco primário é teoria de números. Existem duas
+interfaces distintas que podem ser usadas no Sage:
+
+
+- ``gp`` - o "**G** do **P** ARI" interpretador, e
+
+- ``pari`` - a biblioteca C do PARI.
+
+Por exemplo, os seguintes comandos são duas formas de realizar a mesma
+coisa. Eles parecem idênticos, mas o resultado é na verdade
+diferente, e o que acontece por trás da cena é bastante diferente.
+
+::
+
+ sage: gp('znprimroot(10007)')
+ Mod(5, 10007)
+ sage: pari('znprimroot(10007)')
+ Mod(5, 10007)
+
+No primeiro caso, uma cópia separada do interpretador GP é iniciada
+como um servidor, e a string ``´znprimroot(10007)'`` é enviada,
+calculada pelo GP, e o resultado é armazenado em uma variável no GP
+(que ocupa espaço na memória dos processos do GP que não serão
+liberados). Então o valor dessa variável é exibido. No segundo caso,
+nenhum programa separado é iniciado, e a string
+``´znprimroot(10007)'`` é calculada por uma certa função da biblioteca
+C do PARI. O resultado é armazenado na memória em uso pelo Python, que
+é liberada quando a variável não for mais referenciada. Os objetos
+possuem tipos diferentes:
+
+::
+
+ sage: type(gp('znprimroot(10007)'))
+ <class 'sage.interfaces.gp.GpElement'>
+ sage: type(pari('znprimroot(10007)'))
+ <type 'sage.libs.pari.gen.gen'>
+
+Então qual eu devo usar? Depende do que você está fazendo. A interface
+GP pode fazer absolutamente tudo o que você poderia fazer na linha de
+comando do GP/PARI, pois está simplesmente executando esse programa.
+Em particular, você pode carregar programas complicados em PARI e
+executá-los. Por outro lado, a interface do PARI (via a biblioteca C)
+é muito mais restritiva. Primeiro, nem todas as funções foram
+implementadas. Segundo, bastante código, por exemplo, envolvendo
+integração numérica, não irá funcionar através da interface PARI.
+Todavia, a interface PARI pode ser significamente mais rápida e mais
+robusta do que a interface GP.
+
+(Se a interface GP ficar sem memória para calcular algum comando, ela
+irá silenciosamente e automaticamente duplicar a memória alocada e
+repetir o comando solicitado. Então os seus cálculos não irão ser
+interrompidos se você não antecipou corretamente a quantidade de
+memória que seria necessária. Esse é um truque útil que a interface
+usual do GP não parece fornecer. Com respeito à interface da
+biblioteca C do PARI, ela imediatamente copia cada objeto criado para
+fora da pilha de memória, logo essa pilha nunca irá crescer. Contudo,
+cada objeto não deve exceder 100MB de tamanho, ou a pilha irá estourar
+quando o objeto for criado. Essa procedimento de cópia impõe uma leve
+pena sobre a performace.)
+
+Em resumo, o Sage usa a biblioteca C do pari para fornecer
+funcionalidade similar à fornecida pelo interpretador GP/PARI, exceto
+que com um gerenciamento sofisticado de memória e a linguagem de
+programação Python.
+
+Primeiro criamos uma lista do PARI a partir de uma lista do Python.
+
+::
+
+ sage: v = pari([1,2,3,4,5])
+ sage: v
+ [1, 2, 3, 4, 5]
+ sage: type(v)
+ <type 'sage.libs.pari.gen.gen'>
+
+Cada objeto do PARI é do tipo ``py_pari_gem``. O tipo PARI do objeto
+subjacente pode ser obtido usando a função ``type``.
+
+::
+
+ sage: v.type()
+ 't_VEC'
+
+Em PARI, para criar uma curva elíptica digitamos
+``ellinit([1,2,3,4,5])``. Em Sage é similar, exceto que ``ellnint`` é
+um método que pode ser chamado em qualquer objeto do PARI, por
+exemplo, ``t\_VEC v``.
+
+::
+
+ sage: e = v.ellinit()
+ sage: e.type()
+ 't_VEC'
+ sage: pari(e)[:13]
+ [1, 2, 3, 4, 5, 9, 11, 29, 35, -183, -3429, -10351, 6128487/10351]
+
+Agora que temos um objeto de curva elíptica, podemos calcular algumas
+coisas a respeito dele.
+
+::
+
+ sage: e.elltors()
+ [1, [], []]
+ sage: e.ellglobalred()
+ [10351, [1, -1, 0, -1], 1]
+ sage: f = e.ellchangecurve([1,-1,0,-1])
+ sage: f[:5]
+ [1, -1, 0, 4, 3]
+
+.. index: GAP
+
+.. _section-gap:
+
+GAP
+===
+
+O Sage vem com o GAP 4.4.10 para matemática discreta computacional,
+especialmente teoria de grupos.
+
+Aqui está um exemplo com a função ``IdGroup`` do GAP, a qual usa a
+base de dados opcional sobre grupos que precisa ser instalada
+separadamente, como explicado abaixo.
+
+::
+
+ sage: G = gap('Group((1,2,3)(4,5), (3,4))')
+ sage: G
+ Group( [ (1,2,3)(4,5), (3,4) ] )
+ sage: G.Center()
+ Group( () )
+ sage: G.IdGroup() # requires optional database_gap package
+ [ 120, 34 ]
+ sage: G.Order()
+ 120
+
+Podemos realizar os mesmos cálculos no Sage sem explicitamente evocar
+a interface do GAP da seguinte forma:
+
+::
+
+ sage: G = PermutationGroup([[(1,2,3),(4,5)],[(3,4)]])
+ sage: G.center()
+ Subgroup of (Permutation Group with generators [(3,4), (1,2,3)(4,5)]) generated by [()]
+ sage: G.group_id() # requires optional database_gap package
+ [120, 34]
+ sage: n = G.order(); n
+ 120
+
+(Para alguns recursos adicionais do GAP, você deve instalar dois
+pacotes opcionais. Digite ``sage -optional`` para uma lista e escolha
+o pacote da forma ``gap\_packages-x.y.z``, então digite ``sage -i
+gap\_packages-x.y.z``. Faça o mesmo para ``database\_gap-x.y.z``.
+Alguns pacotes do GAP sem licensa GPL podem ser obtidos no site do GAP
+[GAPkg]_, e copiados em ``$SAGE_ROOT/local/lib/gap-4.4.10/pkg``.)
+
+Singular
+========
+
+O Singular fornece uma biblioteca massiva e madura para bases de
+Gröbner, máximo divisor comum para poliômios em várias variaveis,
+bases de espaços de Riemann-Roch de uma curva plana, e fatorização,
+entre outras coisas. Vamos ilustrar a fatorização de polinômios em
+várias variáveis usando a interface do Sage para o Singular (não
+digite ``...``):
+
+::
+
+ sage: R1 = singular.ring(0, '(x,y)', 'dp')
+ sage: R1
+ // characteristic : 0
+ // number of vars : 2
+ // block 1 : ordering dp
+ // : names x y
+ // block 2 : ordering C
+ sage: f = singular('9*y^8 - 9*x^2*y^7 - 18*x^3*y^6 - 18*x^5*y^6 + \
+ ... 9*x^6*y^4 + 18*x^7*y^5 + 36*x^8*y^4 + 9*x^10*y^4 - 18*x^11*y^2 - \
+ ... 9*x^12*y^3 - 18*x^13*y^2 + 9*x^16')
+
+Agora que definimos :math:`f`, vamos imprimi-lo e fatorá-lo.
+
+::
+
+ sage: f
+ 9*x^16-18*x^13*y^2-9*x^12*y^3+9*x^10*y^4-18*x^11*y^2+36*x^8*y^4+18*x^7*y^5-18*x^5*y^6+9*x^6*y^4-18*x^3*y^6-9*x^2*y^7+9*y^8
+ sage: f.parent()
+ Singular
+ sage: F = f.factorize(); F
+ [1]:
+ _[1]=9
+ _[2]=x^6-2*x^3*y^2-x^2*y^3+y^4
+ _[3]=-x^5+y^2
+ [2]:
+ 1,1,2
+ sage: F[1][2]
+ x^6-2*x^3*y^2-x^2*y^3+y^4
+
+Como com o exemplo para o GAP em :ref:`section-gap`, podemos calcular
+a fatorização acima sem explicitamente usar a inteface do Singular
+(todavia, implicitamente o Sage usa a interface do Singular para os
+cálculos). Não digite ``...``:
+
+::
+
+ sage: x, y = QQ['x, y'].gens()
+ sage: f = 9*y^8 - 9*x^2*y^7 - 18*x^3*y^6 - 18*x^5*y^6 + 9*x^6*y^4\
+ ... + 18*x^7*y^5 + 36*x^8*y^4 + 9*x^10*y^4 - 18*x^11*y^2 - 9*x^12*y^3\
+ ... - 18*x^13*y^2 + 9*x^16
+ sage: factor(f)
+ (9) * (-x^5 + y^2)^2 * (x^6 - 2*x^3*y^2 - x^2*y^3 + y^4)
+
+.. _section-maxima:
+
+Maxima
+======
+
+O Maxima está incluido no Sage, assim como uma implementação do Lisp.
+O pacote gnuplot (que o Maxima usa para criar gráficos) é distribuído
+como um pacote adicional do Sage. Entre outras coisas, o Maxima
+executa manipulações simbólicas. Ele pode integrar e diferenciar
+funções simbolicamente, resolver EDOs de primeira ordem, grande parte
+das EDOs lineares de segunda ordem, e tem implementado o método da
+transformada de Laplace para EDOs lineares de qualquer ordem. O Maxima
+também suporta uma série de funções especiais, é capaz de criar
+gráficos via gnuplot, e possui métodos para resolver equações
+polinômiais e manipular matrizes (por exemplo, escalonar e calcular
+autovalores e autovetores).
+
+Nós ilustramos a interface Sage/Maxima construíndo uma matriz cuja
+entrada :math:`i,j` é :math:`i/j`, para :math:`i,j=1,\ldots,4`.
+
+::
+
+ sage: f = maxima.eval('ij_entry[i,j] := i/j')
+ sage: A = maxima('genmatrix(ij_entry,4,4)'); A
+ matrix([1,1/2,1/3,1/4],[2,1,2/3,1/2],[3,3/2,1,3/4],[4,2,4/3,1])
+ sage: A.determinant()
+ 0
+ sage: A.echelon()
+ matrix([1,1/2,1/3,1/4],[0,0,0,0],[0,0,0,0],[0,0,0,0])
+ sage: A.eigenvalues()
+ [[0,4],[3,1]]
+ sage: A.eigenvectors()
+ [[[0,4],[3,1]],[[[1,0,0,-4],[0,1,0,-2],[0,0,1,-4/3]],[[1,2,3,4]]]]
+
+Aqui vai outro exemplo:
+
+::
+
+ sage: A = maxima("matrix ([1, 0, 0], [1, -1, 0], [1, 3, -2])")
+ sage: eigA = A.eigenvectors()
+ sage: V = VectorSpace(QQ,3)
+ sage: eigA
+ [[[-2,-1,1],[1,1,1]],[[[0,0,1]],[[0,1,3]],[[1,1/2,5/6]]]]
+ sage: v1 = V(sage_eval(repr(eigA[1][0][0]))); lambda1 = eigA[0][0][0]
+ sage: v2 = V(sage_eval(repr(eigA[1][1][0]))); lambda2 = eigA[0][0][1]
+ sage: v3 = V(sage_eval(repr(eigA[1][2][0]))); lambda3 = eigA[0][0][2]
+
+ sage: M = MatrixSpace(QQ,3,3)
+ sage: AA = M([[1,0,0],[1, - 1,0],[1,3, - 2]])
+ sage: b1 = v1.base_ring()
+ sage: AA*v1 == b1(lambda1)*v1
+ True
+ sage: b2 = v2.base_ring()
+ sage: AA*v2 == b2(lambda2)*v2
+ True
+ sage: b3 = v3.base_ring()
+ sage: AA*v3 == b3(lambda3)*v3
+ True
+
+Por fim, apresentamos um exemplo de como usar o Sage para criar
+gráficos usando ``openmath``. Alguns desses exemplos são modificações
+de exemplos do manual de referência do Maxima.
+
+Um gráfico em duas dimensões de diversas funções (não digite ``...``):
+
+::
+
+ sage: maxima.plot2d('[cos(7*x),cos(23*x)^4,sin(13*x)^3]','[x,0,1]',\
+ ... '[plot_format,openmath]') # not tested
+
+Um gráfico em 3D que você pode mover com o seu mouse:
+
+::
+
+ sage: maxima.plot3d ("2^(-u^2 + v^2)", "[u, -3, 3]", "[v, -2, 2]",\
+ ... '[plot_format, openmath]') # not tested
+ sage: maxima.plot3d("atan(-x^2 + y^3/4)", "[x, -4, 4]", "[y, -4, 4]",\
+ ... "[grid, 50, 50]",'[plot_format, openmath]') # not tested
+
+O próximo gráfico é a famosa faixa de Möbious:
+
+::
+
+ sage: maxima.plot3d("[cos(x)*(3 + y*cos(x/2)), sin(x)*(3 + y*cos(x/2)),\
+ ... y*sin(x/2)]", "[x, -4, 4]", "[y, -4, 4]",\
+ ... '[plot_format, openmath]') # not tested
+
+E agora a famosa garrafa de Klein:
+
+::
+
+ sage: maxima("expr_1: 5*cos(x)*(cos(x/2)*cos(y) + sin(x/2)*sin(2*y)+ 3.0)\
+ ... - 10.0")
+ 5*cos(x)*(sin(x/2)*sin(2*y)+cos(x/2)*cos(y)+3.0)-10.0
+ sage: maxima("expr_2: -5*sin(x)*(cos(x/2)*cos(y) + sin(x/2)*sin(2*y)+ 3.0)")
+ -5*sin(x)*(sin(x/2)*sin(2*y)+cos(x/2)*cos(y)+3.0)
+ sage: maxima("expr_3: 5*(-sin(x/2)*cos(y) + cos(x/2)*sin(2*y))")
+ 5*(cos(x/2)*sin(2*y)-sin(x/2)*cos(y))
+ sage: maxima.plot3d ("[expr_1, expr_2, expr_3]", "[x, -%pi, %pi]",\
+ ... "[y, -%pi, %pi]", "['grid, 40, 40]",\
+ ... '[plot_format, openmath]') # not tested
diff --git a/doc/pt/tutorial/introduction.rst b/doc/pt/tutorial/introduction.rst
new file mode 100644
--- /dev/null
+++ b/doc/pt/tutorial/introduction.rst
@@ -0,0 +1,165 @@
+**********
+Introdução
+**********
+
+Este tutorial leva no máximo de 3 a 4 horas para ser percorrido. Você
+pode lê-lo em versão HTML ou PDF, ou a partir do Notebook Sage (clique
+em ``Help``, então clique em ``Tutorial`` para percorrer o tutorial de
+forma interativa).
+
+Embora grande parte do Sage seja implementado em Python, nenhum
+conhecimento de Python é necessário para a leitura deste tutorial.
+Você vai querer aprender Python (uma linguagem muito divertida!) em
+algum momento, e existem diversas opções gratuitas disponíveis para
+isso, entre elas [PyT]_ e [Dive]_ (em inglês). Se você quiser
+experimentar o Sage rapidamente, este tutorial é o lugar certo para
+começar. Por exemplo:
+
+::
+
+ sage: 2 + 2
+ 4
+ sage: factor(-2007)
+ -1 * 3^2 * 223
+
+ sage: A = matrix(4,4, range(16)); A
+ [ 0 1 2 3]
+ [ 4 5 6 7]
+ [ 8 9 10 11]
+ [12 13 14 15]
+
+ sage: factor(A.charpoly())
+ x^2 * (x^2 - 30*x - 80)
+
+ sage: m = matrix(ZZ,2, range(4))
+ sage: m[0,0] = m[0,0] - 3
+ sage: m
+ [-3 1]
+ [ 2 3]
+
+ sage: E = EllipticCurve([1,2,3,4,5]);
+ sage: E
+ Elliptic Curve defined by y^2 + x*y + 3*y = x^3 + 2*x^2 + 4*x + 5
+ over Rational Field
+ sage: E.anlist(10)
+ [0, 1, 1, 0, -1, -3, 0, -1, -3, -3, -3]
+ sage: E.rank()
+ 1
+
+ sage: k = 1/(sqrt(3)*I + 3/4 + sqrt(73)*5/9); k
+ 1/(I*sqrt(3) + 5/9*sqrt(73) + 3/4)
+ sage: N(k)
+ 0.165495678130644 - 0.0521492082074256*I
+ sage: N(k,30) # 30 "bits"
+ 0.16549568 - 0.052149208*I
+ sage: latex(k)
+ \frac{1}{i \, \sqrt{3} + \frac{5}{9} \, \sqrt{73} + \frac{3}{4}}
+
+.. _installation:
+
+Instalação
+==========
+
+Se você não tem o Sage instalado em um computador e quer apenas
+experimentar alguns comandos, use o Sage através do site
+http://www.sagenb.org.
+
+Veja o guia de instalação do Sage na seção de documentação na página
+principal do Sage [SA]_ para instruções de como instalar o Sage no seu
+computador. Aqui faremos apenas alguns comentários.
+
+#. O arquivo para download do Sage vem com "baterias incluídas". Em
+ outras palavras, embora o Sage use o Python, IPython, PARI, GAP,
+ Singular, Maxima, NTL, GMP, e uma série de outros programas, você
+ não precisa instalá-los separadamente pois eles estão incluídos no
+ Sage. Todavia, para usar alguns recursos, por exemplo, o Macaulay
+ ou o KASH, você precisa instalar pacotes de software adicionais ou
+ ter os programas necessários já instalados no seu computador. O
+ Macaulay e o KASH estão disponíveis como pacotes adicionais do Sage
+ (para uma lista de pacotes adicionais, digite ``sage -optional``,
+ ou visite a seção "Download" na página do Sage na internet).
+
+#. A versão pré-compilada do Sage (disponível na página do Sage na
+ internet) pode ser mais fácil e rápida para instalar do que a
+ versão obtida compilando o código fonte.
+
+#. Se você quiser usar o pacote SageTeX (que permite inserir
+ cálculos do Sage em um arquivo LaTeX), você deve tornar
+ o SageTex disponível para a sua distribuição TeX. Para fazer isso,
+ consulte a seção "Make SageTex known to TeX" no `Sage installation
+ guide <http://www.sagemath.org/doc/>`_. O procedimento é bem
+ simples; você precisa apenas definir algumas variáveis no seu
+ sistema ou copiar um arquivo para um diretório onde o TeX poderá
+ encontrá-lo.
+
+ A documentação para usar o SageTex está disponível em
+ ``$SAGE_ROOT/local/share/texmf/tex/generic/sagetex/``, onde
+ ``$SAGE_ROOT`` refere-se ao diretório onde você instalou o Sage
+ -- por exemplo, ``/opt/sage-4.2.1``.
+
+Formas de usar o Sage
+=====================
+
+Você pode usar o Sage de diversas formas.
+
+
+- **Interface gráfica Notebook:** veja a seção sobre o Notebook em
+ :ref:`section-notebook`,
+
+- **Linha de comando interativa:** veja
+ :ref:`chapter-interactive_shell`,
+
+- **Programas:** escrevendo programas interpretados e compilados em
+ Sage (veja :ref:`section-loadattach` e :ref:`section-compile`), e
+
+- **Scripts:** escrevendo scripts em Python que usam a biblioteca do
+ Sage (veja :ref:`section-standalone`).
+
+
+Objetivos do Sage a longo prazo
+===============================
+
+- **Útil**: O público alvo do Sage são estudantes de matemática
+ (desde o ensino médio até a pós-graduação), professores, e
+ pesquisadores em matemática. O objetivo é fornecer um software que
+ possa ser usado para explorar e experimentar construções matemáticas
+ em álgebra, geometria, teoria de números, cálculo, computação
+ numérica, etc. O Sage torna mais fácil a experimentação com objetos
+ matemáticos de forma interativa.
+
+- **Eficiente:** Ser rápido. O Sage usa software bastante otimizado
+ como o GMP, PARI, GAP, e NTL, e portanto é muito rápido em certas
+ operações.
+
+- **Gratuito e de código aberto:** O código fonte deve ser amplamente
+ disponível e legível, de modo que os usuários possam entender o que
+ o software realmente faz e possam facilmente estendê-lo. Da mesma
+ forma que matemáticos ganham entendimento sobre um teorema lendo
+ cuidadosamente a sua demonstração, as pessoas que fazem cálculos
+ deveriam poder entender como os cálculos são feitos lendo o código
+ fonte e seus comentários. Se você usar o Sage para fazer cálculos em
+ um artigo que seja publicado, você pode ter certeza que os leitores
+ sempre terão livre acesso ao Sage e seu código fonte, e você tem até
+ mesmo permissão para arquivar e redistribuir a versão do Sage que
+ você utilizou.
+
+- **Fácil de compilar:** O Sage deve ser fácil de compilar a partir
+ do código fonte para usuários de Linux, OS X e Windows. Isso
+ fornece mais flexibilidade para os usuários modificarem o sistema.
+
+- **Cooperação:** Fornecer uma interface robusta para outros sistemas
+ computacionais, incluindo PARI, GAP, Singular, Maxima, KASH, Magma,
+ Maple e Mathematica. O Sage foi concebido para unificar e estender
+ outros softwares de matemática existentes.
+
+- **Bem documentado:** Tutorial, guia de programação, manual de
+ referência, e how-to, com inúmeros exemplos e discussão sobre
+ conceitos matemáticos relacionados.
+
+- **Estensível:** Ser capaz de definir novos tipos de dados ou
+ derivá-los a partir dos tipos de dados existentes, e usar programas
+ escritos em diversas outras linguagens.
+
+- **Fácil de usar:** Deve ser fácil entender quais recursos estão
+ disponíveis para um determinado objeto e consultar a documentação e
+ o código fonte.
diff --git a/doc/pt/tutorial/latex.rst b/doc/pt/tutorial/latex.rst
new file mode 100644
--- /dev/null
+++ b/doc/pt/tutorial/latex.rst
@@ -0,0 +1,515 @@
+*********************************
+Sage, LaTeX e Companheiros
+*********************************
+
+AUTOR: Rob Beezer (2010-05-23)
+
+O Sage e o dialeto LaTeX do TeX tem um relacionamento sinergético
+intenso. Esta seção tem como objetivo introduzir as diversas formas de
+interação entre eles, começado pelas mais básicas e indo até as menos
+usuais. (Logo você pode não querer ler esta seção inteira na sua
+primeira passagem por este tutorial.)
+
+Panorama Geral
+==============
+
+Pode ser mais fácil entender os vários usos do LaTeX com um panorama
+geral sobre os três principais métodos usados pelo Sage.
+
+#. Todo objeto no Sage possui uma representação em LaTeX. Você
+ pode acessar essa representação executando, no Notebook ou na
+ linha de comando do Sage, ``latex(foo)`` where ``foo`` é algum
+ objeto no Sage. O resultado é uma string que deve fornecer uma
+ representação razoável de ``foo`` no modo matemático em LaTeX
+ (por exemplo, quando cercado por um par de símbolos $). Alguns
+ exemplos disso seguem abaixo.
+
+ Dessa forma, o Sage pode ser usado efetivamente para construir
+ partes de um documento LaTeX: crie ou calcule um objeto no
+ Sage, imprima ``latex()`` do objeto e copie-e-cole o resultado
+ no seu documento.
+
+#. A interface Notebook é configurada para usar o `jsMath
+ <http://www.math.union.edu/~dpvc/jsMath/>`_ para representar
+ fórmulas matemáticas de forma clara em um web browser. O jsMath é
+ uma coleção de rotinas em JavaScript e fontes associadas.
+ Tipicamente esses fontes ficam armazenadas em um servidor e são
+ enviadas para o browser juntamente com a página onde elas estão
+ sendo usadas. No caso do Sage, o Notebook está sempre conectado a
+ um servidor usado para executar os comando do Sage, e esse servidor
+ também fornece as fontes do jsMath necessárias. Logo não é
+ necessário configurar nada mais para ter formulas matemáticas
+ representadas no seu browser quando você usa o Notebook do Sage.
+
+ O jsMath é implementado para representar um subconjunto grande,
+ mas não completo, do TeX. Ele não suporta objetos como, por
+ exemplo, tabelas complicadas e seções, e é focado para
+ representar acuradamente pequenas fórmulas em TeX. A
+ representação automática de fórmulas matemáticas no Notebook é
+ obtida convertendo a representação ``latex()`` de um objeto
+ (como descrito acima) em uma forma de HTML mais adequada ao
+ jsMath.
+
+ Como o jsMath usa as suas próprias fontes de tamanho variável,
+ ele é superior a outros métodos que convertem equações, ou
+ outros pequenos trechos de TeX, em imagens estáticas.
+
+ O jsMath muito provavelmente vai ser substituído pelo MathJAX,
+ uma tecnologia similar do mesmo autor, que possui suporte
+ extenso de editoras técnicas e sociedades profissionais.
+
+#. Na linha de comando do Sage, ou no Notebook quando o código em
+ LaTeX é complicado demais para o jsMath processar, uma
+ instalação local do LaTeX pode ser usada. O Sage inclui quase
+ tudo que você precisa para compilar e usar o Sage, mas uma
+ exceção significativa é o TeX. Então nessas situações você
+ precisa ter o TeX instalado, juntamente com algumas ferramentas
+ de conversão, para usar os recursos completos.
+
+Aqui nós demonstramos alguns usos básicos da função ``latex()``. ::
+
+ sage: var('z')
+ z
+ sage: latex(z^12)
+ z^{12}
+ sage: latex(integrate(z^4, z))
+ \frac{1}{5} \, z^{5}
+ sage: latex('a string')
+ \verb|a|\phantom{x}\verb|string|
+ sage: latex(QQ)
+ \Bold{Q}
+ sage: latex(matrix(QQ, 2, 3, [[2,4,6],[-1,-1,-1]]))
+ \left(\begin{array}{rrr}
+ 2 & 4 & 6 \\
+ -1 & -1 & -1
+ \end{array}\right)
+
+A funcionalidade básica do jsMath é em sua maior parte automática no
+Notebook, mas nós podemos demonstrar esse suporte parcialmente com a
+classe ``jsMath``. A função ``eval`` dessa classe converte um objeto
+do Sage em sua representação LaTeX e adiciona HTML que por sua vez
+evoca a classe "matemática" do CSS, a qual então emprega o jsMath. ::
+
+ sage: from sage.misc.latex import JSMath
+ sage: js = JSMath()
+ sage: var('z')
+ z
+ sage: js(z^12)
+ <html><div class="math">\newcommand{\Bold}[1]{\mathbf{#1}}z^{12}</div></html>
+ sage: js(QQ)
+ <html><div class="math">\newcommand{\Bold}[1]{\mathbf{#1}}\Bold{Q}</div></html>
+ sage: js(ZZ[x])
+ <html><div class="math">\newcommand{\Bold}[1]{\mathbf{#1}}\Bold{Z}[x]</div></html>
+ sage: js(integrate(z^4, z))
+ <html><div class="math">\newcommand{\Bold}[1]{\mathbf{#1}}\frac{1}{5} \, z^{5}</div></html>
+
+Uso Básico
+==========
+
+Como indicado acima, a forma mais simples de explorar o suporte do
+Sage para o LaTeX é usando a função ``latex()`` para criar código
+LaTeX para representar objetos matemáticos. Essas strings podem então
+ser incorporadas em documentos LaTeX. Isso funciona igualmente no
+Notebook ou na linha de comando do Sage.
+
+No outro extremo está o comando ``view()``. Na linha de comando do
+Sage o comando ``view(foo)`` irá criar a representação em LaTeX de
+``foo``, incorporar isso em um documento simples em LaTeX, e então
+processar o documento usando o LaTeX em seu sistema. Por fim, o
+visualizador apropriado será aberto para apresentar o documento
+gerado. Qual versão do TeX é usada, e portanto as opções para a saída
+e visualizador, podem ser personalizados (veja
+:ref:`sec-custom-processing`).
+
+No Notebook, o comando ``view(foo)`` cria uma combinação apropriada de
+HTML e CSS para que o jsMath mostre a representação em LaTeX na folha
+de trabalho. Para o usuário, ele simplesmente cria uma versão
+cuidadosamente formatada do resultado, distinta da saída padrão em
+modo texto do Sage. Nem todo objeto no Sage possui uma representação
+em LaTeX adequada às capacidades limitadas do jsMath. Nesses casos, a
+interpretação pelo jsMath pode ser deixada de lado, e com isso o LaTeX
+do sistema é chamado, e o resultado dessa chamada é convertido em uma
+imagem que é inserida na folha de trabalho. Como alterar e controlar
+esse processo é discutido abaixo na seção
+:ref:`sec-custom-generation`.
+
+O comando interno ``pretty_print()`` ilustra a conversão de objetos do
+Sage para HTML que emprega o jsMath no Notebook. ::
+
+ sage: from sage.misc.latex import pretty_print
+ sage: pretty_print(x^12)
+ <html><span class="math">\newcommand{\Bold}[1]{\mathbf{#1}}x^{12}</span></html>
+ sage: pretty_print(integrate(sin(x), x))
+ <html><span class="math">\newcommand{\Bold}[1]{\mathbf{#1}}-\cos\left(x\right)</span></html>
+
+O Notebook tem outros dois recursos para empregar o TeX. O primeiro é
+o botão "Typeset" bem acima da primeira célula da folha de trabalho, à
+direita dos quatro menus de opções. Quando selecionado, o resultado de
+qualquer cálculo vai ser interpretado pelo jsMath. Note que esse
+efeito não é retroativo -- células calculadas anteriormente precisam
+ser recalculadas para ter o resultado representado pelo jsMath.
+Essencialmente, selecionar o botão "Typeset" é equivalente a aplicar o
+comando ``view()`` ao resultado de cada célula.
+
+Um segundo recurso disponível no Notebook é possibilidade de inserir
+código TeX para fazer anotações na folha de trabalho. Quando o cursos
+esta posicionado entre células de modo que uma barra azul fica
+visível, então shift-click irá abrir um mini processador de texto,
+TinyMCE. Isso permite digitar texto, usando um editor WSISYG para
+criar HTML e CSS. Logo é possível inserir texto formatado para
+complementar a folha de trabalho. Todavia, texto entre símbolos $, ou
+$$, é interpretado pelo jsMath como "inline" ou "display math"
+espectivamente.
+
+.. _sec-custom-generation:
+
+Personalizando a Criação de Código LaTeX
+========================================
+
+Exitem várias formas de personalizar o código LaTeX gerado pelo
+comando ``latex()``. No Notebook e na linha de comando existe um
+objeto pré-definido chamado ``latex`` que possui diversos métodos, os
+quais você pode listar digitando ``latex.``, seguido da tecla tab
+(note a presença do ponto).
+
+Um bom exemplo é o método ``latex.matrix_delimiters``. Ele pode ser
+usado para alterar a notação de matrizes -- parênteses grandes,
+colchetes, barras verticais. Nenhuma noção de estilo é enfatizada,
+você pode configurar como desejado. Observe como as barras invertidas
+usadas em LaTeX requerem uma barra adicional de modo que elas possam
+ser interpretadas (escaped) corretamente em uma string do Python. ::
+
+ sage: A = matrix(ZZ, 2, 2, range(4))
+ sage: latex(A)
+ \left(\begin{array}{rr}
+ 0 & 1 \\
+ 2 & 3
+ \end{array}\right)
+ sage: latex.matrix_delimiters(left='[', right=']')
+ sage: latex(A)
+ \left[\begin{array}{rr}
+ 0 & 1 \\
+ 2 & 3
+ \end{array}\right]
+ sage: latex.matrix_delimiters(left='\\{', right='\\}')
+ sage: latex(A)
+ \left\{\begin{array}{rr}
+ 0 & 1 \\
+ 2 & 3
+ \end{array}\right\}
+
+O método ``latex.vector_delimiters`` funciona de forma similar.
+
+A forma como anéis e corpos comuns podem ser representados pode ser
+controlada pelo método ``latex.blackboard_bold``. Esses conjuntos são
+representados por padrão em negrito, mas podem opcionalmente ser
+escritos em letras duplas como é comum em trabalhos escritos. Isso é
+obtido redefinindo a macro ``\Bold{}`` que faz parte do Sage. ::
+
+ sage: latex(QQ)
+ \Bold{Q}
+ sage: from sage.misc.latex import JSMath
+ sage: js=JSMath()
+ sage: js(QQ)
+ <html><div class="math">\newcommand{\Bold}[1]{\mathbf{#1}}\Bold{Q}</div></html>
+ sage: latex.blackboard_bold(True)
+ sage: js(QQ)
+ <html><div class="math">\newcommand{\Bold}[1]{\mathbb{#1}}\Bold{Q}</div></html>
+ sage: latex.blackboard_bold(False)
+
+É possível aproveitar os recursos do TeX adicionando novas macros e
+novos pacotes. Primeiro, macros individuais podem ser adicionadas para
+serem usadas quando o jsMath interpreta pequenos trechos de códigos
+TeX no Notebook. ::
+
+ sage: latex.extra_macros()
+ ''
+ sage: latex.add_macro("\\newcommand{\\foo}{bar}")
+ sage: latex.extra_macros()
+ '\\newcommand{\\foo}{bar}'
+ sage: var('x y')
+ (x, y)
+ sage: latex(x+y)
+ x + y
+ sage: from sage.misc.latex import JSMath
+ sage: js=JSMath()
+ sage: js(x+y)
+ <html><div class="math">\newcommand{\Bold}[1]{\mathbf{#1}}\newcommand{\foo}{bar}x + y</div></html>
+
+Macros adicionais usadas dessa forma serão também usadas eventualmente
+se a versão do TeX no seu sistema for usada para lidar com algo muito
+complicado para o jsMath. O comando ``latex_extra_preamble`` é usado
+para construir o preambulo de um documento completo em LaTeX.
+Ilustramos a seguir como fazer isso. Novamente note a necessidade de
+barras invertidas duplas nas strings do Python. ::
+
+
+ sage: latex.extra_macros('')
+ sage: latex.extra_preamble('')
+ sage: from sage.misc.latex import latex_extra_preamble
+ sage: print latex_extra_preamble()
+ \newcommand{\ZZ}{\Bold{Z}}
+ ...
+ \newcommand{\Bold}[1]{\mathbf{#1}}
+ sage: latex.add_macro("\\newcommand{\\foo}{bar}")
+ sage: print latex_extra_preamble()
+ \newcommand{\ZZ}{\Bold{Z}}
+ ...
+ \newcommand{\Bold}[1]{\mathbf{#1}}
+ \newcommand{\foo}{bar}
+
+Novamente, para expressões grandes ou mais complicadas do LaTeX, é
+possível adicionar pacotes (ou qualquer outra coisa) ao preambulo do
+arquivo LaTeX. Qualquer coisa pode ser incorporada no preambulo com o
+comando ``latex.add_to_preamble``, e o comando mais especializado
+``latex.add_package_to_preamble_if_available`` irá primeiro verificar
+se certo pacote está realmente disponível antes de adicioná-lo ao
+preambulo
+
+Agora adicionamos o pacote geometry ao preambulo e usamos ele para
+definir o tamanho da região na página que o TeX vai usar
+(efetivamente definido as margens). Novamente, observe a necessidade
+de barras duplas nas strings do Python. ::
+
+
+ sage: from sage.misc.latex import latex_extra_preamble
+ sage: latex.extra_macros('')
+ sage: latex.extra_preamble('')
+ sage: latex.add_to_preamble('\\usepackage{geometry}')
+ sage: latex.add_to_preamble('\\geometry{letterpaper,total={8in,10in}}')
+ sage: latex.extra_preamble()
+ '\\usepackage{geometry}\\geometry{letterpaper,total={8in,10in}}'
+ sage: print latex_extra_preamble()
+ \usepackage{geometry}\geometry{letterpaper,total={8in,10in}}
+ \newcommand{\ZZ}{\Bold{Z}}
+ ...
+ \newcommand{\Bold}[1]{\mathbf{#1}}
+
+Um pacote pode ser adicionado juntamente com a verificação de sua
+existência, da seguinte forma. Como um exemplo, nós ilustramos uma
+tentativa de adicionar ao preambulo um pacote que supostamente não
+existe. ::
+
+ sage: latex.extra_preamble('')
+ sage: latex.extra_preamble()
+ ''
+ sage: latex.add_to_preamble('\\usepackage{foo-bar-unchecked}')
+ sage: latex.extra_preamble()
+ '\\usepackage{foo-bar-unchecked}'
+ sage: latex.add_package_to_preamble_if_available('foo-bar-checked')
+ sage: latex.extra_preamble()
+ '\\usepackage{foo-bar-unchecked}'
+
+.. _sec-custom-processing:
+
+Personalizando o Processamento em LaTeX
+=======================================
+
+É também possível controlar qual variação do TeX é usada quando a
+versão do sistema for evocada, logo influenciando também o resultado.
+De forma similar, é também possível controlar quando o Notebook irá
+usar o jsMath (trechos simples em TeX) ou a versão do TeX do sistema
+(expressões mais complicadas).
+
+O comando ``latex.engine()`` pode ser usado para controlar de os
+executáveis ``latex``, ``pdflatex`` ou ``xelatex`` do sistema são
+usados para processar expressões mais complicadas. Quando ``view()`` é
+chamado na linha de comando do Sage e o processador é definido como
+``latex``, um arquivo dvi é produzido e o Sage vai usar um
+visualizador de dvi (como o xdvi) para apresentar o resultado. Por
+outro lado, usando ``view()`` na linha de comando do Sage, quando o
+processador é definido como ``pdflatex``, irá produzir um PDF e o Sage vai
+executar o programa disponível no seu sistema para visualizar arquivos
+PDF (acrobat, okular, evince, etc.).
+
+No Notebook, é necessário interver na decisão de se o jsMath vai
+interpretar trechos em TeX, ou se o LaTeX do sistema deve fazer o
+trabalho se o código em LaTeX for complicado demais. O dispositivo é
+uma lista de strings, que se forem encontradas em um trecho de código
+LaTeX sinalizam para o Notebook usar o LaTeX (ou qualquer executável
+que for definido pelo comando ``latex.engine()``). Essa lista é
+gerenciada pelos comandos ``latex.add_to_jsmath_avoid_list`` e
+``latex.jsmath_avoid_list``. ::
+
+ sage: latex.jsmath_avoid_list([])
+ sage: latex.jsmath_avoid_list()
+ []
+ sage: latex.jsmath_avoid_list(['foo', 'bar'])
+ sage: latex.jsmath_avoid_list()
+ ['foo', 'bar']
+ sage: latex.add_to_jsmath_avoid_list('tikzpicture')
+ sage: latex.jsmath_avoid_list()
+ ['foo', 'bar', 'tikzpicture']
+ sage: latex.jsmath_avoid_list([])
+ sage: latex.jsmath_avoid_list()
+ []
+
+Suponha que uma expressão em LaTeX é produzida no Notebook com o
+comando ``view()`` ou enquanto o botão "Typeset" está selecionado, e
+então reconhecida, através da "lista de comandos a serem evitados no
+jsMath", como necessitando a versão do LaTeX no sistema. Então o
+executável selecionado (como especificado por ``latex.engine()``) irá
+processar o código em LaTeX. Todavia, em vez de então abrir um
+visualizador externo (o que é o comportamento na linha de comando), o
+Sage irá tentar converter o resultado em uma imagem, que então é
+inserida na folha de trabalho como o resultado da célula.
+
+Exatamente como essa conversão é feita depende de vários fatores --
+qual executável você especificou como processador e quais utilitários
+de conversão estão disponíveis no seu sistema. Quatro conversores
+usuais que irão cobrir todas as ocorrências são o ``dvips``,
+``ps2pdf``, e ``dvipng``, e do pacote ``ImageMagick``, o ``convert``.
+O objetivo é produzir um arquivo PNG para ser inserido de volta na
+folha de trabalho. Quando uma expressão em LaTeX pode ser convertida
+com sucesso em um arquivo dvi pelo processador LaTeX, então o dvipng
+deve dar conta da conversão. Se a expressão em LaTeX e o processador
+especificado criarem um arquivo dvi com conteúdo especial que o dvipng
+não pode converter, então o dvips vai criar um arquivo PostScript.
+Esse arquivo PostScript, ou um PDF criado por pelo processador
+``pdflatex``, é então convertido em um arquivo dvi pelo programa
+``convert``. A presença de dois desses conversores pode ser testado
+com as rotinas ``have_dvipng()`` e ``have_convert()``.
+
+Essas conversões são feitas automaticamente se você tiver os
+conversores necessários instalados; se não, então uma mensagem de erro
+é impressa dizendo o que está faltando e onde obter.
+
+Para um exemplo concreto de como expressões complicadas em LaTeX podem
+ser processadas, veja o exemplo na próxima seção
+(:ref:`sec-tkz-graph`) para usar o pacote ``tkz-graph`` para produzir
+ilustrações de grafos combinatoriais de alta qualidade. Para outros
+exemplos, existem alguns casos teste incluídos no Sage. Para usá-los,
+é necessário importar o objeto ``sage.misc.latex.latex_examples``, que
+é uma instância da classe ``sage.misc.latex.LatexExamples``, como
+mostrado abaixo. Essa classe possui exemplos de diagramas comutativos,
+grafos combinatoriais, teoria de nós e pstricks, os quais
+respectivamente testam os seguintes pacotes: xy, tkz-graph, xypic,
+pstricks. Após importar o objeto, use completamento tab em
+``latex_examples`` para ver os exemplos disponíveis. Ao carregar um
+exemplo você irá obter explicações sobre o que é necessário para fazer
+o conteúdo do exemplo ser exibido corretamente. Para de fato ver os
+exemplos, é necessário usar ``view()`` (uma vez que o preambulo,
+processador, etc. estão configurados corretamente).
+
+::
+
+ sage: from sage.misc.latex import latex_examples
+ sage: latex_examples.diagram()
+ LaTeX example for testing display of a commutative diagram produced
+ by xypic.
+ <BLANKLINE>
+ To use, try to view this object -- it won't work. Now try
+ 'latex.add_to_preamble("\\usepackage[matrix,arrow,curve,cmtip]{xy}")',
+ and try viewing again -- it should work in the command line but not
+ from the notebook. In the notebook, run
+ 'latex.add_to_jsmath_avoid_list("xymatrix")' and try again -- you
+ should get a picture (a part of the diagram arising from a filtered
+ chain complex).
+
+.. _sec-tkz-graph:
+
+Exemplo: Grafos Combinatoriais com tkz-graph
+============================================
+
+Ilustrações de alta qualidade de grafos combinatoriais (daqui por
+diante, simplesmente grafos) são possíveis com o pacote ``tkz-graph``.
+Esse pacote baseia-se no ``tikz`` front-end da biblioteca ``pgf``.
+Logo todos esses componentes precisam ser parte de uma instalação
+completa do LaTeX em seu sistema, e pode acontecer que alguns desses
+componentes não estejam em sua versão mais recente em algumas
+distribuições do TeX. Logo, para melhores resultados, seria necessário
+ou recomendável instalar esses pacotes como parte do seu diretório
+texmf pessoal. Criar, manter e personalizar uma instalação do TeX no
+sistema ou em um diretório pessoal vai além do escopo deste documento,
+mas deve ser fácil encontrar instruções para isso. Os arquivos
+necessários estão listados em :ref:`sec-system-wide-tex`.
+
+Portanto, para começar precisamos nos certificar que os pacotes
+relevantes estão incluídos adicionando-os ao preambulo do eventual
+documento LaTeX. As imagens dos grafos não são formadas corretamente
+quando um arquivo dvi é usando como formato intermediário, logo é
+melhor definir o processador do LaTeX como ``pdflatex``. A esta altura
+um comando como ``view(graphs.CompleteGraph(4))`` deve funcionar na
+linha de comando do Sage e produzir um PDF com a imagem completa do
+grafo `K_4`.
+
+Para uma experiência semelhante no Notebook, é necessário desabilitar
+o processador jsMath para o código LaTeX do grafo usando a "lista de
+comandos a serem evitados pelo jsMath". Grafos são criados usando o
+environment ``tikzpicture``, logo essa uma boa escolha para uma string
+a ser incluída na lista que acabamos de mencionar. Agora,
+``view(graphs.CompleteGraph(4))`` em uma folha de trabalho deve
+executar o pdflatex para criar um PDF e então o programa ``convert``
+para obter um gráfico PNG que vai ser inserido na folha de trabalho.
+Os seguintes comandos ilustram os passos para obter grafos processados
+pelo LaTeX no Notebook. ::
+
+ sage: from sage.graphs.graph_latex import setup_latex_preamble
+ sage: setup_latex_preamble()
+ sage: latex.extra_preamble() # random - depends on system's TeX installation
+ '\\usepackage{tikz}\n\\usepackage{tkz-graph}\n\\usepackage{tkz-berge}\n'
+ sage: latex.engine('pdflatex')
+ sage: latex.add_to_jsmath_avoid_list('tikzpicture')
+ sage: latex.jsmath_avoid_list()
+ ['tikzpicture']
+
+Agora, um comando como ``view(graphs.CompleteGraph(4))`` deve produzir
+um gráfico do grafo no Notebook, tendo usado ``pdflatex`` para
+processar os comandos do ``tkz-graph`` para construir o grafo. Note
+que há diversas opções que afetam o resultado do gráfico obtido usando
+o LaTeX via ``tkz-graph``, o que mais uma vez está além do escopo
+desta seção (veja a seção do Manual de Referência com título "Opções
+do LaTeX para Grafos" para instruções e detalhes).
+
+.. _sec-system-wide-tex:
+
+Uma Instalação Completa do TeX
+==============================
+Vários dos recursos avançados de integração do TeX com o Sage requerem
+uma instalação do TeX em seu sistema. Várias versões do Linux possuem
+pacotes do TeX baseados no TeX-live, para o OSX existe o TeXshop e
+para o windows existe o MikTex. O utilitário ``convert`` é parte do
+`ImageMagick <http://www.imagemagick.org/>`_ (que deve ser um pacote
+na sua versão do Linux ou ser fácil de instalar), e os três programas
+``dvipng``, ``ps2pdf``, e ``dvips`` podem estar incluídos na sua
+distribuição do TeX. Os dois primeiros podem também ser obtidos em,
+respectivamente, http://sourceforge.net/projects/dvipng/ e como parte
+do `Ghostscript <http://www.ghostscript.com/>`_.
+
+A criação de grafos combinatoriais requer uma versão recente da
+biblioteca PGF, e os arquivos ``tkz-graph.sty``, ``tkz-arith.sty`` e
+talvez ``tkz-berge.sty``, que estão disponíveis em `Altermundus site
+<http://altermundus.com/pages/graph.html>`_.
+
+Programas Externos
+==================
+
+Existem três programas disponíveis para integrar ainda mais o TeX e o
+Sage. O primeiro é o sagetex. Uma descrição concisa do sagetex é que
+ele é uma coleção de macros do TeX que permitem incluir em um
+documento LaTeX instruções para usar o Sage para calcular vários
+objetos, e/ou formatar objetos usando o comando ``latex()`` existente
+no Sage. Logo, como um passo intermediário para compilar um documento
+LaTeX, todos os recursos computacionais e de formatação do Sage podem
+ser executados automaticamente. Como um exemplo, um exame matemático
+pode manter uma correspondência entre questões e respostas usando o
+sagetex para fazer cálculos com o Sage. Veja :ref:`sec-sagetex` para
+mais informações.
+
+O tex2sws começa com um documento LaTeX, mas define environments
+adicionais para inserir código em Sage. Quando processado com as
+ferramentas adequadas, o resultado é uma folha de trabalho do Sage,
+com conteúdo apropriadamente formatado para o jsMath e com código em
+Sage incorporado como células de entrada. Então um livro texto ou
+artigo pode ser criado em LaTeX, ter blocos de código em Sage
+incluídos, e o documento todo pode ser transformado em uma folha de
+trabalho do Sage onde o texto matemático é bem formatado e os blocos
+de código em Sage podem ser facilmente executados. Atualmente em
+desenvolvimento, veja `tex2sws @ BitBucket
+<http://bitbucket.org/rbeezer/tex2sws/>`_ para mais informações.
+
+O sws2tex reverte o processo partindo de uma folha de trabalho do Sage
+e convertendo o conteúdo para LaTeX para ser posteriormente processado
+com as ferramentas disponíveis para documentos em LaTeX. Atualmente em
+desenvolvimento, veja `sws2tex @ BitBucket
+<http://bitbucket.org/whuss/sws2tex/>`_ para mais informações.
diff --git a/doc/pt/tutorial/programming.rst b/doc/pt/tutorial/programming.rst
new file mode 100644
--- /dev/null
+++ b/doc/pt/tutorial/programming.rst
@@ -0,0 +1,850 @@
+***********
+Programação
+***********
+
+.. _section-loadattach:
+
+Carregando e Anexando Arquivos do Sage
+======================================
+
+A seguir ilustramos como carregar no Sage programas escritos em um
+arquivo separado. Crie um arquivo chamado ``example.sage`` com o
+seguinte conteúdo:
+
+.. skip
+
+::
+
+ print "Hello World"
+ print 2^3
+
+Você pode ler e executar o arquivo ``example.sage`` usando o comando
+``load``.
+
+.. skip
+
+::
+
+ sage: load "example.sage"
+ Hello World
+ 8
+
+Você também pode anexar um arquivo em Sage à sessão em execução usando
+o comando ``attach``.
+
+.. skip
+
+::
+
+ sage: attach "example.sage"
+ Hello World
+ 8
+
+Agora se você alterar ``example.sage`` e adicionar uma linha em branco
+(por exemplo), então o conteúdo de ``example.sage`` será
+automaticamente recarregado no Sage.
+
+Em particular, ``attach`` automaticamente recarrega um arquivo toda
+vez que ele for modificado, o que é útil para desenvolver e testar um
+programa, enquanto ``load`` carrega o arquivo apenas uma vez.
+
+Quando o Sage carrega ``example.sage`` ele converte esse arquivo para
+o Python, o qual é então executado pelo interpretador do Python. Essa
+conversão é mínima; ela essencialmente consiste em encapsular inteiros
+em ``Integer()``, números float em ``RealNumber()``, substituir ``^``
+por ``**``, e substituir, por exemplo, ``R.2`` por ``R.gen(2)``. A
+versão convertida de ``example.sage`` é armazenada no mesmo diretório
+de ``example.sage`` e é chamada ``example.sage.py``. Esse arquivo
+contém o seguinte código:
+
+::
+
+ print "Hello World"
+ print Integer(2)**Integer(3)
+
+Inteiros literais são encapsulados e ``^`` é substituído por ``**``.
+(Em Python, ``^`` significa "ou exclusivo" e ``**`` significa
+"exponenciação".)
+
+Esse "preparsing" está implementado em ``sage/misc/interpreter.py``.)
+
+Você pode colar código tabulado com muitas linhas no Sage desde que
+existam linhas em branco separando blocos de código (isso não é
+necessário em arquivos). Todavia, a melhor forma de adicionar tal
+código a uma sessão do Sage é salvá-lo em um arquivo e usar
+``attach``, como descrito anteriormente.
+
+
+.. _section-compile:
+
+Criando Código Compilado
+========================
+
+Velocidade é crucial em cálculos matemáticos. Embora o Python seja uma
+linguagem conveniente de alto nível, certos cálculos podem ser várias
+vezes mais rápidos do que em Python se eles forem implementados usando
+tipos estáticos em uma linguagem compilada. Alguns aspectos do Sage
+seriam muito lentos se eles fossem escritos inteiramente em Python.
+Para lidar com isso, o Sage suporta uma "versão" compilada do Python
+chamada Cython ([Cyt]_ and [Pyr]_). O Cython é simultaneamente similar
+ao Python e ao C. A maior parte das construções em Python, incluindo
+"list comprehensions", expressões condicionais, código como ``+=`` são
+permitidos; você também pode importar código que você escreveu em
+outros módulos em Python. Além disso, você pode declarar variáveis em
+C arbitrárias, e qualquer chamada de bibliotecas em C pode ser feita
+diretamente. O código resultante é convertido para C e compilado
+usando um compilador para C.
+
+Para criar o seu próprio código compilado em Sage, nomeie o arquivo
+com uma extensão ``.spyx`` (em vez de ``.sage``). Se você está
+trabalhando na linha de comando, você pode anexar e carregar código
+compilado exatamente como se faz com código interpretado (no momento,
+anexar e carregar código em Cython não é suportado no Notebook). A
+compilação é realizada implicitamente sem que você tenha que fazer
+qualquer coisa explicitamente. Veja
+``$SAGE_ROOT/examples/programming/sagex/factorial.spyx`` para um
+exemplo de uma implementação compilada para a função fatorial que usa
+diretamente a biblioteca GMP em C. Experimente o seguinte, usando cd,
+vá para o diretório ``$SAGE_ROOT/examples/programming/sagex/``, e
+então faça o seguinte:
+
+.. skip
+
+::
+
+ sage: load "factorial.spyx"
+ ***************************************************
+ Recompiling factorial.spyx
+ ***************************************************
+ sage: factorial(50)
+ 30414093201713378043612608166064768844377641568960512000000000000L
+ sage: time n = factorial(10000)
+ CPU times: user 0.03 s, sys: 0.00 s, total: 0.03 s
+ Wall time: 0.03
+
+Aqui o sufixo L indica um "long integer" do Python (veja
+:ref:`section-mathannoy`).
+
+Note que o Sage vai recompilar ``factorial.spyx`` se você encerrar e
+reiniciar o Sage. A biblioteca compilada e compartilhada é armazenada
+em ``$HOME/.sage/temp/hostname/pid/spyx``. Esses arquivos são
+excluídos quando você encerra o Sage.
+
+Nenhum pré-processador (preparsing) é aplicado em arquivos spyx, por
+exemplo, ``1/3`` vai resultar em 0 em um arquivo spyx em vez do número
+racional :math:`1/3`. Se ``foo`` é uma função da biblioteca Sage, para
+usá-la em um arquivo spyx importe ``sage.all`` e use ``sage.all.foo``.
+
+::
+
+ import sage.all
+ def foo(n):
+ return sage.all.factorial(n)
+
+Acessando Funções em C em Arquivos Separados
+--------------------------------------------
+
+É fácil também acessar funções em C definidas em arquivos \*.c
+separados. Aqui vai um exemplo. Crie os arquivos ``test.c`` e
+``test.spyx`` no mesmo diretório contendo:
+
+Código C puro: ``test.c``
+
+::
+
+ int add_one(int n) {
+ return n + 1;
+ }
+
+Código Cython: ``test.spyx``:
+
+::
+
+ cdef extern from "test.c":
+ int add_one(int n)
+
+ def test(n):
+ return add_one(n)
+
+Então o seguinte funciona:
+
+.. skip
+
+::
+
+ sage: attach "test.spyx"
+ Compiling (...)/test.spyx...
+ sage: test(10)
+ 11
+
+Se uma biblioteca ``foo`` adicional é necessária para compilar código
+em C gerado a partir de um arquivo em Cython, adicione a linha ``clib
+foo`` no arquivo fonte em Cython. De forma similar, um arquivo em C
+adicional ``bar`` pode ser incluído na compilação declarando ``cfile
+bar``.
+
+.. _section-standalone:
+
+Scripts Independentes em Python/Sage
+====================================
+
+O seguinte script em Sage fatora inteiros, polinômios, etc:
+
+::
+
+ #!/usr/bin/env sage -python
+
+ import sys
+ from sage.all import *
+
+ if len(sys.argv) != 2:
+ print "Usage: %s <n>"%sys.argv[0]
+ print "Outputs the prime factorization of n."
+ sys.exit(1)
+
+ print factor(sage_eval(sys.argv[1]))
+
+Para usar esse script, sua ``SAGE_ROOT`` precisa estar na sua variável
+PATH. Se o script acima for chamado ``factor``, aqui está um exemplo
+de como usá-lo:
+
+::
+
+ bash $ ./factor 2006
+ 2 * 17 * 59
+ bash $ ./factor "32*x^5-1"
+ (2*x - 1) * (16*x^4 + 8*x^3 + 4*x^2 + 2*x + 1)
+
+Tipo de Dados
+=============
+
+Cada objeto em Sage possui um tipo bem definido. O Python possui
+diversos tipos de dados, e a biblioteca do Sage adiciona ainda mais.
+Os tipos de dados de Python incluem strings, listas, tuplas, inteiros
+e floats, como ilustrado:
+
+::
+
+ sage: s = "sage"; type(s)
+ <type 'str'>
+ sage: s = 'sage'; type(s) # you can use either single or double quotes
+ <type 'str'>
+ sage: s = [1,2,3,4]; type(s)
+ <type 'list'>
+ sage: s = (1,2,3,4); type(s)
+ <type 'tuple'>
+ sage: s = int(2006); type(s)
+ <type 'int'>
+ sage: s = float(2006); type(s)
+ <type 'float'>
+
+Além disso, o Sage acrescenta vários outros tipos. Por exemplo,
+espaços vetoriais:
+
+::
+
+ sage: V = VectorSpace(QQ, 1000000); V
+ Vector space of dimension 1000000 over Rational Field
+ sage: type(V)
+ <class 'sage.modules.free_module.FreeModule_ambient_field_with_category'>
+
+Apenas certas funções podem ser aplicadas sobre ``V``. Em outros
+softwares de matemática, essas seriam chamadas usando a notação
+"funcional" ``foo(V,...)``. Em Sage, algumas funções estão anexadas ao
+tipo (ou classe) de ``V``, e são chamadas usando uma sintaxe orientada
+a objetos como em Java ou C++, por exemplo, ``V.foo()``. Isso ajuda a
+manter o espaço de variáveis global sem milhares de funções, e permite
+que várias funções diferentes com comportamento diferente possam ser
+chamadas foo, sem a necessidade de usar um mecanismo de identificação
+de tipos (ou casos) para decidir qual chamar. Além disso, se você
+reutilizar o nome de uma função, essa função continua ainda disponível
+(por exemplo, se você chamar algo ``zeta``, e então quiser calcular o
+valor da função zeta de Riemann em 0.5, você continua podendo digitar
+``s=.5; s.zeta()``).
+
+::
+
+ sage: zeta = -1
+ sage: s=.5; s.zeta()
+ -1.46035450880959
+
+Em alguns casos muito comuns, a notação funcional usual é também
+suportada por conveniência e porque expressões matemáticas podem
+parecer confusas usando a notação orientada a objetos. Aqui vão alguns
+exemplos.
+
+::
+
+ sage: n = 2; n.sqrt()
+ sqrt(2)
+ sage: sqrt(2)
+ sqrt(2)
+ sage: V = VectorSpace(QQ,2)
+ sage: V.basis()
+ [
+ (1, 0),
+ (0, 1)
+ ]
+ sage: basis(V)
+ [
+ (1, 0),
+ (0, 1)
+ ]
+ sage: M = MatrixSpace(GF(7), 2); M
+ Full MatrixSpace of 2 by 2 dense matrices over Finite Field of size 7
+ sage: A = M([1,2,3,4]); A
+ [1 2]
+ [3 4]
+ sage: A.charpoly('x')
+ x^2 + 2*x + 5
+ sage: charpoly(A, 'x')
+ x^2 + 2*x + 5
+
+Para listar todas as funções para :math:`A`, use completamento tab.
+Simplesmente digite ``A.``, então tecle ``[tab]`` no seu teclado, como
+descrito em :ref:`section-tabcompletion`.
+
+Listas, Tuplas e Sequências
+===========================
+
+O tipo de dados lista armazena elementos de um tipo arbitrário. Como
+em C, C++, etc. (mas diferentemente da maioria dos sistemas de álgebra
+computacional), os elementos da lista são indexados a partir do
+:math:`0`:
+
+::
+
+ sage: v = [2, 3, 5, 'x', SymmetricGroup(3)]; v
+ [2, 3, 5, 'x', Symmetric group of order 3! as a permutation group]
+ sage: type(v)
+ <type 'list'>
+ sage: v[0]
+ 2
+ sage: v[2]
+ 5
+
+(Quando se indexa uma lista, é permitido que o índice não seja um int
+do Python!) Um Inteiro do Sage (ou Racional, ou qualquer objeto que
+possua um método ``__index__``) também ira funcionar.
+
+::
+
+ sage: v = [1,2,3]
+ sage: v[2]
+ 3
+ sage: n = 2 # SAGE Integer
+ sage: v[n] # Perfectly OK!
+ 3
+ sage: v[int(n)] # Also OK.
+ 3
+
+A função ``range`` cria uma lista de int's do Python (não Inteiros do
+Sage):
+
+::
+
+ sage: range(1, 15)
+ [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
+
+Isso é útil quando se usa "list comprehensions" para construir listas:
+
+::
+
+ sage: L = [factor(n) for n in range(1, 15)]
+ sage: print L
+ [1, 2, 3, 2^2, 5, 2 * 3, 7, 2^3, 3^2, 2 * 5, 11, 2^2 * 3, 13, 2 * 7]
+ sage: L[12]
+ 13
+ sage: type(L[12])
+ <class 'sage.structure.factorization_integer.IntegerFactorization'>
+ sage: [factor(n) for n in range(1, 15) if is_odd(n)]
+ [1, 3, 5, 7, 3^2, 11, 13]
+
+Para mais sobre como criar listas usando "list comprehensions", veja
+[PyT]_.
+
+Fatiamento de lista (list slicing) é um recurso fantástico. Se ``L`` é
+uma lista, então ``L[m:n]`` retorna uma sub-lista de ``L`` obtida
+começando do :math:`m`-ésimo elemento e terminando no
+:math:`(n-1)`-ésimo elemento, como ilustrado abaixo.
+
+::
+
+ sage: L = [factor(n) for n in range(1, 20)]
+ sage: L[4:9]
+ [5, 2 * 3, 7, 2^3, 3^2]
+ sage: print L[:4]
+ [1, 2, 3, 2^2]
+ sage: L[14:4]
+ []
+ sage: L[14:]
+ [3 * 5, 2^4, 17, 2 * 3^2, 19]
+
+Tuplas são semelhantes à listas, exceto que elas são imutáveis: uma
+vez criadas elas não podem ser alteradas.
+
+::
+
+ sage: v = (1,2,3,4); v
+ (1, 2, 3, 4)
+ sage: type(v)
+ <type 'tuple'>
+ sage: v[1] = 5
+ Traceback (most recent call last):
+ ...
+ TypeError: 'tuple' object does not support item assignment
+
+Sequências são um terceiro tipo de dados do Sage semelhante a listas.
+Diferentemente de listas e tuplas, Sequence não é um tipo de dados
+nativo do Python. Por definição, uma sequência é mutável, mas usando o
+método ``set_immutable`` da classe ``Sequence`` elas podem ser feitas
+imutáveis, como mostra o exemplo a seguir. Todos os elementos da
+sequência possuem um parente comum, chamado o universo da sequência.
+
+::
+
+ sage: v = Sequence([1,2,3,4/5])
+ sage: v
+ [1, 2, 3, 4/5]
+ sage: type(v)
+ <class 'sage.structure.sequence.Sequence_generic'>
+ sage: type(v[1])
+ <type 'sage.rings.rational.Rational'>
+ sage: v.universe()
+ Rational Field
+ sage: v.is_immutable()
+ False
+ sage: v.set_immutable()
+ sage: v[0] = 3
+ Traceback (most recent call last):
+ ...
+ ValueError: object is immutable; please change a copy instead.
+
+Sequências são derivadas de listas e podem ser usadas em qualquer
+lugar que listas são usadas.
+
+::
+
+ sage: v = Sequence([1,2,3,4/5])
+ sage: isinstance(v, list)
+ True
+ sage: list(v)
+ [1, 2, 3, 4/5]
+ sage: type(list(v))
+ <type 'list'>
+
+Como um outro exemplo, bases para espaços vetoriais são sequências
+imutáveis, pois é importante que elas não sejam modificadas.
+
+::
+
+ sage: V = QQ^3; B = V.basis(); B
+ [
+ (1, 0, 0),
+ (0, 1, 0),
+ (0, 0, 1)
+ ]
+ sage: type(B)
+ <class 'sage.structure.sequence.Sequence_generic'>
+ sage: B[0] = B[1]
+ Traceback (most recent call last):
+ ...
+ ValueError: object is immutable; please change a copy instead.
+ sage: B.universe()
+ Vector space of dimension 3 over Rational Field
+
+Dicionários
+===========
+
+Um dicionário (também chamado as vezes de lista associativa) é um
+mapeamento de objetos "hashable" em objetos arbitrários. (Exemplos de
+objetos "hashable" são strings e números; veja a documentação Python
+em http://docs.python.org/tut/node7.html e
+http://docs.python.org/lib/typesmapping.html para detalhes).
+
+::
+
+ sage: d = {1:5, 'sage':17, ZZ:GF(7)}
+ sage: type(d)
+ <type 'dict'>
+ sage: d.keys()
+ [1, 'sage', Integer Ring]
+ sage: d['sage']
+ 17
+ sage: d[ZZ]
+ Finite Field of size 7
+ sage: d[1]
+ 5
+
+A terceira chave (key) ilustra como os índices de um dicionário podem
+ser complicados, por exemplo, um anel de inteiros.
+
+Você pode transformar o dicionário acima em uma lista com os mesmos
+dados:
+
+.. link
+
+::
+
+ sage: d.items()
+ [(1, 5), ('sage', 17), (Integer Ring, Finite Field of size 7)]
+
+É comum iterar sobre os pares em um dicionário:
+
+::
+
+ sage: d = {2:4, 3:9, 4:16}
+ sage: [a*b for a, b in d.iteritems()]
+ [8, 27, 64]
+
+Um dicionário não possui ordem, como o exemplo acima mostra.
+
+Conjuntos
+=========
+
+O Python possui um tipo set (conjuntos) nativo. O principal recurso
+que ele oferece é a rápida verificação se um objeto está ou não em um
+conjunto, juntamente com as operações comuns em conjuntos.
+
+::
+
+ sage: X = set([1,19,'a']); Y = set([1,1,1, 2/3])
+ sage: X
+ set(['a', 1, 19])
+ sage: Y
+ set([1, 2/3])
+ sage: 'a' in X
+ True
+ sage: 'a' in Y
+ False
+ sage: X.intersection(Y)
+ set([1])
+
+O Sage também possui o seu próprio tipo de dados para conjuntos que é
+(em alguns casos) implementado usando o tipo nativo do Python, mas
+possuir algumas funcionalidades adicionais. Crie um conjunto em Sage
+usando ``Set(...)``. Por exemplo,
+
+::
+
+ sage: X = Set([1,19,'a']); Y = Set([1,1,1, 2/3])
+ sage: X
+ {'a', 1, 19}
+ sage: Y
+ {1, 2/3}
+ sage: X.intersection(Y)
+ {1}
+ sage: print latex(Y)
+ \left\{1, \frac{2}{3}\right\}
+ sage: Set(ZZ)
+ Set of elements of Integer Ring
+
+Iteradores
+==========
+
+Iteradores foram adicionados recentemente ao Python e são
+particularmente úteis em aplicações matemáticas. Aqui estão vários
+exemplos; veja [PyT]_ para mais detalhes. Vamos criar um iterador
+sobre o quadrados dos números inteiros até :math:`10000000`.
+
+::
+
+ sage: v = (n^2 for n in xrange(10000000))
+ sage: v.next()
+ 0
+ sage: v.next()
+ 1
+ sage: v.next()
+ 4
+
+Criamos agora um iterador sobre os primos da forma :math:`4p+1` com
+:math:`p` também primo, e observamos os primeiros valores.
+
+::
+
+ sage: w = (4*p + 1 for p in Primes() if is_prime(4*p+1))
+ sage: w # in the next line, 0xb0853d6c is a random 0x number
+ <generator object at 0xb0853d6c>
+ sage: w.next()
+ 13
+ sage: w.next()
+ 29
+ sage: w.next()
+ 53
+
+Certos anéis, por exemplo, corpos finitos e os inteiros possuem
+iteradores associados a eles:
+
+::
+
+ sage: [x for x in GF(7)]
+ [0, 1, 2, 3, 4, 5, 6]
+ sage: W = ((x,y) for x in ZZ for y in ZZ)
+ sage: W.next()
+ (0, 0)
+ sage: W.next()
+ (0, 1)
+ sage: W.next()
+ (0, -1)
+
+Laços, Funções, Enunciados de Controle e Comparações
+====================================================
+
+Nós já vimos alguns exemplos de alguns usos comuns de laços (loops)
+``for``. Em Python, um laço ``for`` possui uma estrutura tabulada, tal
+como
+
+::
+
+ >>> for i in range(5):
+ print(i)
+
+ 0
+ 1
+ 2
+ 3
+ 4
+
+Note que os dois pontos no final do enunciado (não existe "do" ou "od"
+como no GAP ou Maple), e a identação antes dos comandos dentro do
+laço, isto é, ``print(i)``. A tabulação é importante. No Sage, a
+tabulação é automaticamente adicionada quando você digita ``enter``
+após ":", como ilustrado abaixo.
+
+::
+
+ sage: for i in range(5):
+ ... print(i) # now hit enter twice
+ 0
+ 1
+ 2
+ 3
+ 4
+
+O símbolo ``=`` é usado para atribuição.
+O símbolo ``==`` é usado para verificar igualdade:
+
+::
+
+ sage: for i in range(15):
+ ... if gcd(i,15) == 1:
+ ... print(i)
+ 1
+ 2
+ 4
+ 7
+ 8
+ 11
+ 13
+ 14
+
+Tenha em mente como a tabulação determina a estrutura de blocos para
+enunciados ``if``, ``for``, e ``while``:
+
+::
+
+ sage: def legendre(a,p):
+ ... is_sqr_modp=-1
+ ... for i in range(p):
+ ... if a % p == i^2 % p:
+ ... is_sqr_modp=1
+ ... return is_sqr_modp
+
+ sage: legendre(2,7)
+ 1
+ sage: legendre(3,7)
+ -1
+
+Obviamente essa não é uma implementação eficiente do símbolo de
+Legendre! O objetivo é ilustrar vários aspectos da programação em
+Python/Sage. A função {kronecker}, que já vem com o Sage, calcula o
+símbolo de Legendre eficientemente usando uma biblioteca em C do PARI.
+
+Finalmente, observamos que comparações, tais como ``==``, ``!=``,
+``<=``, ``>=``, ``>``, ``<``, entre números irão automaticamente
+converter ambos os números para o mesmo tipo, se possível:
+
+::
+
+ sage: 2 < 3.1; 3.1 <= 1
+ True
+ False
+ sage: 2/3 < 3/2; 3/2 < 3/1
+ True
+ True
+
+Quase todos pares de objetos podem ser comparados; não se supõe que os
+objetos estejam equipados com uma ordem total.
+
+::
+
+ sage: 2 < CC(3.1,1)
+ True
+ sage: 5 < VectorSpace(QQ,3) # output can be somewhat random
+ True
+
+Use bool para desigualdades simbólicas:
+
+::
+
+ sage: x < x + 1
+ x < x + 1
+ sage: bool(x < x + 1)
+ True
+
+Quando se compara objetos de tipos diferentes no Sage, na maior parte
+dos casos o Sage tenta encontrar uma coação canônica para ambos os
+objetos em um parente comum (veja :ref:`section-coercion` para mais
+detalhes). Se isso for bem sucedido, a comparação é realizada entre os
+objetos que foram coagidos; se não for bem sucedido, os objetos são
+considerados diferentes. Para testar se duas variáveis fazem
+referência ao mesmo objeto use ``is``. Como se vê no próximo exemplo,
+o int ``1`` do Python é único, mas o Inteiro ``1`` do Sage não é.
+
+::
+
+ sage: 1 is 2/2
+ False
+ sage: int(1) is int(2)/int(2)
+ True
+ sage: 1 is 1
+ False
+ sage: 1 == 2/2
+ True
+
+Nas duas linhas seguintes, a primeira igualdade é falsa (``False``)
+porque não existe um morfismo canônico :math:`QQ\to \GF{5}`, logo
+não há uma forma de comparar o :math:`1` em :math:`\GF{5}` com o
+:math:`1 \in \QQ`. Em contraste, existe um mapa canônico entre
+:math:`\ZZ \to \GF{5}`, logo a segunda comparação é verdadeira
+(``True``)
+
+::
+
+ sage: GF(5)(1) == QQ(1); QQ(1) == GF(5)(1)
+ False
+ False
+ sage: GF(5)(1) == ZZ(1); ZZ(1) == GF(5)(1)
+ True
+ True
+ sage: ZZ(1) == QQ(1)
+ True
+
+ATENÇÃO: Comparação no Sage é mais restritiva do que no Magma, o qual
+declara :math:`1 \in \GF{5}` igual a :math:`1 \in \QQ`.
+
+::
+
+ sage: magma('GF(5)!1 eq Rationals()!1') # optional magma required
+ true
+
+Otimização (Profiling)
+======================
+
+Autor desta seção: Martin Albrecht (malb@informatik.uni-bremen.de)
+
+ "Premature optimization is the root of all evil." - Donald Knuth
+
+As vezes é útil procurar por gargalos em programas para entender quais
+partes gastam maior tempo computacional; isso pode dar uma boa ideia
+sobre quais partes otimizar. Python e portanto Sage fornecem várias
+opções de "profiling" (esse é o nome que se dá ao processo de
+otimização).
+
+O mais simples de usar é o comando ``prun`` na linha de comando
+interativa. Ele retorna um sumário sobre o tempo computacional
+utilizado por cada função. Para analisar (a atualmente lenta! -- na
+versão 1.0) multiplicação de matrizes sobre corpos finitos, por
+exemplo, faça o seguinte:
+
+::
+
+ sage: k,a = GF(2**8, 'a').objgen()
+ sage: A = Matrix(k,10,10,[k.random_element() for _ in range(10*10)])
+
+.. skip
+
+::
+
+ sage: %prun B = A*A
+ 32893 function calls in 1.100 CPU seconds
+
+ Ordered by: internal time
+
+ ncalls tottime percall cumtime percall filename:lineno(function)
+ 12127 0.160 0.000 0.160 0.000 :0(isinstance)
+ 2000 0.150 0.000 0.280 0.000 matrix.py:2235(__getitem__)
+ 1000 0.120 0.000 0.370 0.000 finite_field_element.py:392(__mul__)
+ 1903 0.120 0.000 0.200 0.000 finite_field_element.py:47(__init__)
+ 1900 0.090 0.000 0.220 0.000 finite_field_element.py:376(__compat)
+ 900 0.080 0.000 0.260 0.000 finite_field_element.py:380(__add__)
+ 1 0.070 0.070 1.100 1.100 matrix.py:864(__mul__)
+ 2105 0.070 0.000 0.070 0.000 matrix.py:282(ncols)
+ ...
+
+Aqui ``ncalls`` é o números de chamadas, ``tottime`` é o tempo total
+gasto por uma determinada função (excluíndo o tempo gasto em chamadas
+de subfunções), ``percall`` é o quociente de ``tottime`` dividido por
+``ncalls``. ``cumtime`` é o tempo total gasto nessa e em todas as
+subfunções (isto é, desde o início até o término da execução da
+função), ``percall`` é o quociente de ``cumtime`` dividido pelas
+chamadas primitivas, e ``filename:lineno(function)`` fornece os dados
+respectivos para cada função. A regra prática aqui é: Quanto mais no
+topo uma função aparece nessa lista, mais custo computacional ela
+acarreta. Logo é mais interessante para ser optimizada.
+
+Como usual, ``prun?`` fornece detalhes sobre como usar o "profiler" e
+como entender a saída de dados.
+
+A saída de dados pode ser escrita em um objeto para permitir uma
+análise mais detalhada:
+
+.. skip
+
+::
+
+ sage: %prun -r A*A
+ sage: stats = _
+ sage: stats?
+
+Note: digitando ``stats = prun -r A\*A`` obtém-se um erro de sintaxe
+porque prun é um comando do IPython, não uma função comum.
+
+Para uma representação gráfica dos dados do "profiling", você pode
+usar o "hotspot profiler", um pequeno script chamado
+``hotshot2cachetree`` e o programa ``kcachegrind`` (apenas no Unix). O
+mesmo exemplo agora com o "hotspot profiler":
+
+.. skip
+
+::
+
+ sage: k,a = GF(2**8, 'a').objgen()
+ sage: A = Matrix(k,10,10,[k.random_element() for _ in range(10*10)])
+ sage: import hotshot
+ sage: filename = "pythongrind.prof"
+ sage: prof = hotshot.Profile(filename, lineevents=1)
+
+.. skip
+
+::
+
+ sage: prof.run("A*A")
+ <hotshot.Profile instance at 0x414c11ec>
+ sage: prof.close()
+
+Isso resulta em um arquivo ``pythongrind.prof`` no diretório de
+trabalho atual. Ele pode ser convertido para o formato cachegrind para
+visualização.
+
+Em uma linha de comando do sistema, digite
+
+.. skip
+
+::
+
+ hotshot2calltree -o cachegrind.out.42 pythongrind.prof
+
+O arquivo de saída ``cachegrind.out.42`` pode ser examinado com
+``kcachegrind``. Note que a convenção de nomes ``cachegrind.out.XX``
+precisa ser obedecida.
diff --git a/doc/pt/tutorial/sagetex.rst b/doc/pt/tutorial/sagetex.rst
new file mode 100644
--- /dev/null
+++ b/doc/pt/tutorial/sagetex.rst
@@ -0,0 +1,112 @@
+.. _sec-sagetex:
+
+****************
+Usando o SageTeX
+****************
+
+O pacote SageTeX permite que você insira resultados de cálculos feitos
+com o Sage em um documento LaTeX. Esse pacote já vem com o Sage. Para
+usá-lo, você precisa "instalá-lo" em seu sistema LaTeX local; aqui
+instalar significa copiar um simples arquivo. Veja :ref:`installation`
+neste tutorial e a seção "Make SageTeX known to TeX" do `Guia de
+instalação do Sage <http://sagemath.org/doc/installation/index.html>`_
+(em inglês) (`este link <../installation/index.html>`_ deve levá-lo a
+uma cópia local do guia de instalação para mais informações de como
+proceder.
+
+Aqui vai um breve exemplo de como usar o SageTeX. A documentação
+completa pode ser encontrada em
+``SAGE_ROOT/local/share/texmf/tex/generic/sagetex``, onde
+``SAGE_ROOT`` é o diretório onde se encontra a sua instalação. Esse
+diretório contém a documentação, um arquivo de exemplo, e alguns
+scripts em Python possivelmente úteis.
+
+Para ver como o SageTeX funciona, siga as instruções para instalar o
+SageTeX (em :ref:`installation`) e copie o seguinte texto em um
+arquivo chamado ``st_example.tex``, por exemplo.
+
+.. warning::
+
+ O texto abaixo vai apresentar diversos erros sobre "unknown control
+ sequences" se você está visualizando isto na ajuda "live". Use a
+ versão estática para ver o texto corretamente.
+
+.. code-block:: latex
+
+ \documentclass{article}
+ \usepackage{sagetex}
+
+ \begin{document}
+
+ Using Sage\TeX, one can use Sage to compute things and put them into
+ your \LaTeX{} document. For example, there are
+ $\sage{number_of_partitions(1269)}$ integer partitions of $1269$.
+ You don't need to compute the number yourself, or even cut and paste
+ it from somewhere.
+
+ Here's some Sage code:
+
+ \begin{sageblock}
+ f(x) = exp(x) * sin(2*x)
+ \end{sageblock}
+
+ The second derivative of $f$ is
+
+ \[
+ \frac{\mathrm{d}^{2}}{\mathrm{d}x^{2}} \sage{f(x)} =
+ \sage{diff(f, x, 2)(x)}.
+ \]
+
+ Here's a plot of $f$ from $-1$ to $1$:
+
+ \sageplot{plot(f, -1, 1)}
+
+ \end{document}
+
+Execute o LaTeX em ``st_example.tex`` da forma usual. Note que o LaTeX
+vai reclamar sobre algumas coisas, entre elas::
+
+ Package sagetex Warning: Graphics file
+ sage-plots-for-st_example.tex/plot-0.eps on page 1 does not exist. Plot
+ command is on input line 25.
+
+ Package sagetex Warning: There were undefined Sage formulas and/or
+ plots. Run Sage on st_example.sage, and then run LaTeX on
+ st_example.tex again.
+
+Observe que, além dos arquivos usuais produzidos pelo LaTeX, existe um
+arquivo chamado ``st_example.sage``. Esse é um script em Sage
+produzido quando você executa o LaTeX em ``st_example.tex``. A
+mensagem de alerta pede para você executar o LaTeX em
+``st_example.sage``, então siga essa sugestão e faça isso. Você vai
+receber uma mensagem para executar o LaTeX em ``st_example.tex``
+novamente, mas antes que você faça isso, observe que um novo arquivo
+foi criado: ``st_example.sout``. Esse arquivo contém os resultados dos
+cálculos feitos pelo Sage, em um formato que o LaTeX pode usar para
+inserir em seu texto. Um novo diretório contendo um arquivo EPS do seu
+gráfico também foi criado. Execute o LaTeX novamente e você vai ver
+que tudo que foi calculado, incluindo os gráficos, foi incluído em seu
+documento.
+
+As macros utilizadas acima devem ser fáceis de entender. Um
+environment ``sageblock`` insere código "verbatim" (exatamente como é
+digitado) e também executa o código quando você executa o Sage. Quando
+você insere ``\sage{foo}``, é incluído em seu documento o resultado
+que você obteria executando ``latex(foo)`` no Sage. Comandos para
+fazer gráficos são um pouco mais complicados, mas em sua forma mais
+simples, ``\sageplot{foo}`` insere a imagem que você obtêm usando
+``foo.save('filename.eps')``.
+
+Em geral, a rotina é a seguinte:
+
+ - execute o LaTeX no seu arquivo .tex;
+ - execute o Sage no arquivo .sage que foi gerado;
+ - execute o LaTeX novamente.
+
+Você pode omitir a execução do Sage desde que você não tenha alterado
+os comandos em Sage em seu documento.
+
+Há muito mais sobre o SageTeX, e como tanto o Sage como o LaTeX são
+ferramentas complexas e poderosas, é uma boa idéia ler a documentação
+para o SageTeX que se encontra em
+``SAGE_ROOT/local/share/texmf/tex/generic/sagetex``.
diff --git a/doc/pt/tutorial/tour.rst b/doc/pt/tutorial/tour.rst
new file mode 100644
--- /dev/null
+++ b/doc/pt/tutorial/tour.rst
@@ -0,0 +1,31 @@
+*****************
+Um passeio guiado
+*****************
+
+Esta seção é um passeio guiado pelo que está disponível no Sage. Para
+diversos outros exemplos, veja "Construções em Sage", que tem como
+objetivo responder à questão geral "Como eu construo ...?". Veja
+também o "Sage Reference Manual", que possui centenas de outros
+exemplos. Note que é também possível percorrer este tutorial no Sage
+Notebook clicando no link ``Help``.
+
+(Se você está acessando este tutorial no Sage Notebook, pressione
+``shift-enter`` para processar qualquer célula de entrada. Você pode
+até editar a célula antes de pressionar ``shift-enter``. Em alguns
+Macs pode ser necessário pressionar ``shift-return`` em vez de
+``shift-enter``.)
+
+.. toctree::
+
+ tour_assignment
+ tour_help
+ tour_algebra
+ tour_plotting
+ tour_functions
+ tour_rings
+ tour_linalg
+ tour_polynomial
+ tour_coercion
+ tour_groups
+ tour_numtheory
+ tour_advanced
diff --git a/doc/pt/tutorial/tour_advanced.rst b/doc/pt/tutorial/tour_advanced.rst
new file mode 100644
--- /dev/null
+++ b/doc/pt/tutorial/tour_advanced.rst
@@ -0,0 +1,548 @@
+Um Pouco Mais de Matemática Avançada
+====================================
+
+Geometria Algébrica
+-------------------
+
+Você pode definir variedades algébricas arbitrárias no Sage, mas as
+vezes alguma funcionalidade não-trivial é limitada a anéis sobre
+:math:`\QQ` ou corpos finitos. Por exemplo, vamos calcular a união de
+duas curvas planas afim, e então recuperar as curvas como as
+componentes irredutíveis da união.
+
+::
+
+ sage: x, y = AffineSpace(2, QQ, 'xy').gens()
+ sage: C2 = Curve(x^2 + y^2 - 1)
+ sage: C3 = Curve(x^3 + y^3 - 1)
+ sage: D = C2 + C3
+ sage: D
+ Affine Curve over Rational Field defined by
+ x^5 + x^3*y^2 + x^2*y^3 + y^5 - x^3 - y^3 - x^2 - y^2 + 1
+ sage: D.irreducible_components()
+ [
+ Closed subscheme of Affine Space of dimension 2 over Rational Field defined by:
+ x^2 + y^2 - 1,
+ Closed subscheme of Affine Space of dimension 2 over Rational Field defined by:
+ x^3 + y^3 - 1
+ ]
+
+Você também pode encontrar todos os pontos de interseção das duas
+curvas, intersectando-as, e então calculando as componentes
+irredutíveis.
+
+.. link
+
+::
+
+ sage: V = C2.intersection(C3)
+ sage: V.irreducible_components()
+ [
+ Closed subscheme of Affine Space of dimension 2 over Rational Field defined by:
+ y - 1,
+ x,
+ Closed subscheme of Affine Space of dimension 2 over Rational Field defined by:
+ y,
+ x - 1,
+ Closed subscheme of Affine Space of dimension 2 over Rational Field defined by:
+ x + y + 2,
+ 2*y^2 + 4*y + 3
+ ]
+
+Portanto, por exemplo, :math:`(1,0)` e :math:`(0,1)` estão em ambas as
+curvas (o que é claramente visível), como também estão certos pontos
+(quadráticos) cuja coordenada :math:`y` satisfaz :math:`2y^2 + 4y +
+3=0`.
+
+O Sage pode calcular o ideal toroidal da cúbica torcida no espaço-3
+projetivo:
+
+::
+
+ sage: R.<a,b,c,d> = PolynomialRing(QQ, 4)
+ sage: I = ideal(b^2-a*c, c^2-b*d, a*d-b*c)
+ sage: F = I.groebner_fan(); F
+ Groebner fan of the ideal:
+ Ideal (b^2 - a*c, c^2 - b*d, -b*c + a*d) of Multivariate Polynomial Ring
+ in a, b, c, d over Rational Field
+ sage: F.reduced_groebner_bases ()
+ [[-c^2 + b*d, -b*c + a*d, -b^2 + a*c],
+ [c^2 - b*d, -b*c + a*d, -b^2 + a*c],
+ [c^2 - b*d, b*c - a*d, -b^2 + a*c, -b^3 + a^2*d],
+ [c^2 - b*d, b*c - a*d, b^3 - a^2*d, -b^2 + a*c],
+ [c^2 - b*d, b*c - a*d, b^2 - a*c],
+ [-c^2 + b*d, b^2 - a*c, -b*c + a*d],
+ [-c^2 + b*d, b*c - a*d, b^2 - a*c, -c^3 + a*d^2],
+ [c^3 - a*d^2, -c^2 + b*d, b*c - a*d, b^2 - a*c]]
+ sage: F.polyhedralfan()
+ Polyhedral fan in 4 dimensions of dimension 4
+
+Curvas Elípticas
+----------------
+
+A funcionalidade para curvas elípticas inclui a maior parte da
+funcionalidade para curvas elípticas do PARI, acesso aos dados da base
+de dados Cremona (isso requer um pacote adicional), os recursos do
+mwrank, isto é, "2-descends" com cálculos do grupo de Mordell-Weil
+completo, o algoritmo SEA (singla em inglês), cálculo de todas as
+isogenias, bastante código novo para curvas sobre :math:`\QQ`, e parte
+do software "algebraic descent" de Denis Simons.
+
+O comando ``EllipticCurve`` para criar curvas elípticas possui várias
+formas:
+
+
+- EllipticCurve([:math:`a_1`, :math:`a_2`, :math:`a_3`, :math:`a_4`, :math:`a_6`]):
+ Fornece a curva elíptica
+
+ .. math:: y^2+a_1xy+a_3y=x^3+a_2x^2+a_4x+a_6,
+
+
+ onde os :math:`a_i`'s são coagidos para os parentes de :math:`a_1`.
+ Se todos os :math:`a_i` possuem parente :math:`\ZZ`, então eles são
+ coagidos para :math:`\QQ`.
+
+- EllipticCurve([:math:`a_4`, :math:`a_6`]): Conforme acima, mas
+ :math:`a_1=a_2=a_3=0`.
+
+- EllipticCurve(label): Fornece a curva elíptica da base de dados
+ Cremona com o "label" (novo) dado. O label é uma string, tal como
+ ``"11a"`` ou ``"37b2"``. As letras devem ser minúsculas (para
+ distinguir dos labels antigos).
+
+- EllipticCurve(j): Fornece uma curva elíptica com invariante
+ :math:`j`.
+
+- EllipticCurve(R,
+ [:math:`a_1`, :math:`a_2`, :math:`a_3`, :math:`a_4`, :math:`a_6`]):
+ Cria uma curva elíptica sobre um anel :math:`R` com os
+ :math:`a_i`'s.
+
+
+Agora ilustramos cada uma dessas construções:
+
+::
+
+ sage: EllipticCurve([0,0,1,-1,0])
+ Elliptic Curve defined by y^2 + y = x^3 - x over Rational Field
+
+ sage: EllipticCurve([GF(5)(0),0,1,-1,0])
+ Elliptic Curve defined by y^2 + y = x^3 + 4*x over Finite Field of size 5
+
+ sage: EllipticCurve([1,2])
+ Elliptic Curve defined by y^2 = x^3 + x + 2 over Rational Field
+
+ sage: EllipticCurve('37a')
+ Elliptic Curve defined by y^2 + y = x^3 - x over Rational Field
+
+ sage: EllipticCurve_from_j(1)
+ Elliptic Curve defined by y^2 + x*y = x^3 + 36*x + 3455 over Rational Field
+
+ sage: EllipticCurve(GF(5), [0,0,1,-1,0])
+ Elliptic Curve defined by y^2 + y = x^3 + 4*x over Finite Field of size 5
+
+O par :math:`(0,0)` é um ponto na curva elíptica :math:`E` definida
+por :math:`y^2 + y = x^3 - x`. Para criar esse ponto digite
+``E([0,0])``. O Sage pode somar pontos em uma curva elíptica
+(lembre-se que é possível definir uma estrutura de grupo aditivo em
+curvas elípticas onde o ponto no infinito é o elemento nulo, e a some
+de três pontos colineares sobre a curva é zero):
+
+::
+
+ sage: E = EllipticCurve([0,0,1,-1,0])
+ sage: E
+ Elliptic Curve defined by y^2 + y = x^3 - x over Rational Field
+ sage: P = E([0,0])
+ sage: P + P
+ (1 : 0 : 1)
+ sage: 10*P
+ (161/16 : -2065/64 : 1)
+ sage: 20*P
+ (683916417/264517696 : -18784454671297/4302115807744 : 1)
+ sage: E.conductor()
+ 37
+
+As curvas elípticas sobre os números complexos são parametrizadas
+pelo invariante :math:`j`. O Sage calcula o invariante :math:`j` da
+seguinte forma:
+
+::
+
+ sage: E = EllipticCurve([0,0,0,-4,2]); E
+ Elliptic Curve defined by y^2 = x^3 - 4*x + 2 over Rational Field
+ sage: E.conductor()
+ 2368
+ sage: E.j_invariant()
+ 110592/37
+
+Se criarmos uma curva com o mesmo invariante :math:`j` que a curva
+:math:`E`, ela não precisa ser isomórfica a :math:`E`. No seguinte
+exemplo, as curvas não são isomórficas porque os seus condutores são
+diferentes.
+
+::
+
+ sage: F = EllipticCurve_from_j(110592/37)
+ sage: F.conductor()
+ 37
+
+Todavia, uma torção de :math:`F` por um fator 2 resulta em uma curva
+isomórfica.
+
+.. link
+
+::
+
+ sage: G = F.quadratic_twist(2); G
+ Elliptic Curve defined by y^2 = x^3 - 4*x + 2 over Rational Field
+ sage: G.conductor()
+ 2368
+ sage: G.j_invariant()
+ 110592/37
+
+Nós podemos calcular os coeficientes :math:`a_n` de uma
+série-:math:`L` ou forma modular :math:`\sum_{n=0}^\infty
+a_nq^n` associada à curva elíptica. Esse cálculo usa a biblioteca C do
+PARI.
+
+::
+
+ sage: E = EllipticCurve([0,0,1,-1,0])
+ sage: print E.anlist(30)
+ [0, 1, -2, -3, 2, -2, 6, -1, 0, 6, 4, -5, -6, -2, 2, 6, -4, 0, -12, 0, -4,
+ 3, 10, 2, 0, -1, 4, -9, -2, 6, -12]
+ sage: v = E.anlist(10000)
+
+Leva apenas um segundo para calcular todos os :math:`a_n` para
+:math:`n\leq 10^5`:
+
+.. skip
+
+::
+
+ sage: %time v = E.anlist(100000)
+ CPU times: user 0.98 s, sys: 0.06 s, total: 1.04 s
+ Wall time: 1.06
+
+Curvas elípticas podem ser construídas usando o "label" da base de
+dados Cremona. Isso importa a curva elíptica com informações prévias
+sobre o seu posto, números de Tomagawa, regulador, etc.
+
+::
+
+ sage: E = EllipticCurve("37b2")
+ sage: E
+ Elliptic Curve defined by y^2 + y = x^3 + x^2 - 1873*x - 31833 over Rational
+ Field
+ sage: E = EllipticCurve("389a")
+ sage: E
+ Elliptic Curve defined by y^2 + y = x^3 + x^2 - 2*x over Rational Field
+ sage: E.rank()
+ 2
+ sage: E = EllipticCurve("5077a")
+ sage: E.rank()
+ 3
+
+Nós também podemos acessar a base de dados Cremona diretamente.
+
+::
+
+ sage: db = sage.databases.cremona.CremonaDatabase()
+ sage: db.curves(37)
+ {'a1': [[0, 0, 1, -1, 0], 1, 1], 'b1': [[0, 1, 1, -23, -50], 0, 3]}
+ sage: db.allcurves(37)
+ {'a1': [[0, 0, 1, -1, 0], 1, 1],
+ 'b1': [[0, 1, 1, -23, -50], 0, 3],
+ 'b2': [[0, 1, 1, -1873, -31833], 0, 1],
+ 'b3': [[0, 1, 1, -3, 1], 0, 3]}
+
+Os objetos obtidos pela base de dados não são do tipo
+``EllipticCurve``. Eles são elementos de uma base de dados e possuem
+alguns campos, e apenas isso. Existe uma versão básica da base de
+dados Cremona, que já é distribuída na versão padrão do Sage, e contém
+informações limitadas sobre curvas elípticas de condutor :math:`\leq
+10000`. Existe também uma versão estendida opcional, que contém
+informações extensas sobre curvas elípticas de condutor :math:`\leq
+120000` (em outubro de 2005). Por fim, existe ainda uma versão (2GB)
+opcional de uma base de dados para o Sage que contém centenas de
+milhares de curvas elípticas na base de dados Stein-Watkins.
+
+Caracteres de Dirichlet
+-----------------------
+
+Um *caractere de Dirichlet* é a extensão de um homomorfismo
+:math:`(\ZZ/N\ZZ)* \to R^*`, para algum anel :math:`R`, para o mapa
+:math:`\ZZ \to R` obtido mapeando os inteiros :math:`x` tais que
+:math:`\gcd(N,x)>1` em 0.
+
+::
+
+ sage: G = DirichletGroup(12)
+ sage: G.list()
+ [Dirichlet character modulo 12 of conductor 1 mapping 7 |--> 1, 5 |--> 1,
+ Dirichlet character modulo 12 of conductor 4 mapping 7 |--> -1, 5 |--> 1,
+ Dirichlet character modulo 12 of conductor 3 mapping 7 |--> 1, 5 |--> -1,
+ Dirichlet character modulo 12 of conductor 12 mapping 7 |--> -1, 5 |--> -1]
+ sage: G.gens()
+ (Dirichlet character modulo 12 of conductor 4 mapping 7 |--> -1, 5 |--> 1,
+ Dirichlet character modulo 12 of conductor 3 mapping 7 |--> 1, 5 |--> -1)
+ sage: len(G)
+ 4
+
+Tendo criado o grupo, a seguir calculamos um elemento e fazemos
+cálculos com ele.
+
+.. link
+
+::
+
+ sage: G = DirichletGroup(21)
+ sage: chi = G.1; chi
+ Dirichlet character modulo 21 of conductor 7 mapping 8 |--> 1, 10 |--> zeta6
+ sage: chi.values()
+ [0, 1, zeta6 - 1, 0, -zeta6, -zeta6 + 1, 0, 0, 1, 0, zeta6, -zeta6, 0, -1,
+ 0, 0, zeta6 - 1, zeta6, 0, -zeta6 + 1, -1]
+ sage: chi.conductor()
+ 7
+ sage: chi.modulus()
+ 21
+ sage: chi.order()
+ 6
+ sage: chi(19)
+ -zeta6 + 1
+ sage: chi(40)
+ -zeta6 + 1
+
+É também possível calcular a ação do grupo de Galois
+:math:`\text{Gal}(\QQ(\zeta_N)/\QQ)` sobre esses caracteres, bem como
+a decomposição em produto direto correspondente à fatorização do
+módulo.
+
+.. link
+
+::
+
+ sage: chi.galois_orbit()
+ [Dirichlet character modulo 21 of conductor 7 mapping 8 |--> 1, 10 |--> zeta6,
+ Dirichlet character modulo 21 of conductor 7 mapping 8 |--> 1, 10 |--> -zeta6 + 1]
+
+ sage: go = G.galois_orbits()
+ sage: [len(orbit) for orbit in go]
+ [1, 2, 2, 1, 1, 2, 2, 1]
+
+ sage: G.decomposition()
+ [
+ Group of Dirichlet characters of modulus 3 over Cyclotomic Field of order
+ 6 and degree 2,
+ Group of Dirichlet characters of modulus 7 over Cyclotomic Field of order
+ 6 and degree 2
+ ]
+
+A seguir, construímos o grupo de caracteres de Dirichlet mod 20, mas
+com valores em :math:`\QQ(i)`:
+
+::
+
+ sage: K.<i> = NumberField(x^2+1)
+ sage: G = DirichletGroup(20,K)
+ sage: G
+ Group of Dirichlet characters of modulus 20 over Number Field in i with defining polynomial x^2 + 1
+
+Agora calculamos diversos invariantes de ``G``:
+
+.. link
+
+::
+
+ sage: G.gens()
+ (Dirichlet character modulo 20 of conductor 4 mapping 11 |--> -1, 17 |--> 1,
+ Dirichlet character modulo 20 of conductor 5 mapping 11 |--> 1, 17 |--> i)
+
+ sage: G.unit_gens()
+ [11, 17]
+ sage: G.zeta()
+ i
+ sage: G.zeta_order()
+ 4
+
+No próximo exemplo criamos um caractere de Dirichlet com valores em um
+corpo numérico. Nós especificamos explicitamente a escolha da raiz da
+unidade no terceiro argumento do comando ``DirichletGroup`` abaixo.
+
+::
+
+ sage: x = polygen(QQ, 'x')
+ sage: K = NumberField(x^4 + 1, 'a'); a = K.0
+ sage: b = K.gen(); a == b
+ True
+ sage: K
+ Number Field in a with defining polynomial x^4 + 1
+ sage: G = DirichletGroup(5, K, a); G
+ Group of Dirichlet characters of modulus 5 over Number Field in a with
+ defining polynomial x^4 + 1
+ sage: chi = G.0; chi
+ Dirichlet character modulo 5 of conductor 5 mapping 2 |--> a^2
+ sage: [(chi^i)(2) for i in range(4)]
+ [1, a^2, -1, -a^2]
+
+Aqui ``NumberField(x^4 + 1, 'a')`` diz para o Sage usar o símbolo "a"
+quando imprimir o que é ``K`` (um corpo numérico definido pelo
+polinômio :math:`x^4 + 1`). O nome "a" não está declarado até então.
+Uma vez que ``a = K.0`` (ou equivalentemente ``a = K.gen()``) é
+calculado, o símbolo "a" representa a raiz do polinômio gerador
+:math:`x^4+1`.
+
+Formas Modulares
+----------------
+
+O Sage pode fazer alguns cálculos relacionados a formas modulares,
+incluindo dimensões, calcular espaços de símbolos modulares,
+operadores de Hecke, e decomposições.
+
+Existem várias funções disponíveis para calcular dimensões de espaços
+de formas modulares. Por exemplo,
+
+::
+
+ sage: dimension_cusp_forms(Gamma0(11),2)
+ 1
+ sage: dimension_cusp_forms(Gamma0(1),12)
+ 1
+ sage: dimension_cusp_forms(Gamma1(389),2)
+ 6112
+
+A seguir ilustramos o cálculo dos operadores de Hecke em um espaço de
+símbolos modulares de nível :math:`1` e peso :math:`12`.
+
+::
+
+ sage: M = ModularSymbols(1,12)
+ sage: M.basis()
+ ([X^8*Y^2,(0,0)], [X^9*Y,(0,0)], [X^10,(0,0)])
+ sage: t2 = M.T(2)
+ sage: t2
+ Hecke operator T_2 on Modular Symbols space of dimension 3 for Gamma_0(1)
+ of weight 12 with sign 0 over Rational Field
+ sage: t2.matrix()
+ [ -24 0 0]
+ [ 0 -24 0]
+ [4860 0 2049]
+ sage: f = t2.charpoly('x'); f
+ x^3 - 2001*x^2 - 97776*x - 1180224
+ sage: factor(f)
+ (x - 2049) * (x + 24)^2
+ sage: M.T(11).charpoly('x').factor()
+ (x - 285311670612) * (x - 534612)^2
+
+Podemos também criar espaços para :math:`\Gamma_0(N)` e
+:math:`\Gamma_1(N)`.
+
+
+::
+
+ sage: ModularSymbols(11,2)
+ Modular Symbols space of dimension 3 for Gamma_0(11) of weight 2 with sign
+ 0 over Rational Field
+ sage: ModularSymbols(Gamma1(11),2)
+ Modular Symbols space of dimension 11 for Gamma_1(11) of weight 2 with
+ sign 0 and over Rational Field
+
+Vamos calcular alguns polinômios característicos e expansões
+:math:`q`.
+
+::
+
+ sage: M = ModularSymbols(Gamma1(11),2)
+ sage: M.T(2).charpoly('x')
+ x^11 - 8*x^10 + 20*x^9 + 10*x^8 - 145*x^7 + 229*x^6 + 58*x^5 - 360*x^4
+ + 70*x^3 - 515*x^2 + 1804*x - 1452
+ sage: M.T(2).charpoly('x').factor()
+ (x - 3) * (x + 2)^2 * (x^4 - 7*x^3 + 19*x^2 - 23*x + 11)
+ * (x^4 - 2*x^3 + 4*x^2 + 2*x + 11)
+ sage: S = M.cuspidal_submodule()
+ sage: S.T(2).matrix()
+ [-2 0]
+ [ 0 -2]
+ sage: S.q_expansion_basis(10)
+ [
+ q - 2*q^2 - q^3 + 2*q^4 + q^5 + 2*q^6 - 2*q^7 - 2*q^9 + O(q^10)
+ ]
+
+Podemos até mesmo calcular espaços de símbolos modulares com carácter.
+
+::
+
+ sage: G = DirichletGroup(13)
+ sage: e = G.0^2
+ sage: M = ModularSymbols(e,2); M
+ Modular Symbols space of dimension 4 and level 13, weight 2, character
+ [zeta6], sign 0, over Cyclotomic Field of order 6 and degree 2
+ sage: M.T(2).charpoly('x').factor()
+ (x - 2*zeta6 - 1) * (x - zeta6 - 2) * (x + zeta6 + 1)^2
+ sage: S = M.cuspidal_submodule(); S
+ Modular Symbols subspace of dimension 2 of Modular Symbols space of
+ dimension 4 and level 13, weight 2, character [zeta6], sign 0, over
+ Cyclotomic Field of order 6 and degree 2
+ sage: S.T(2).charpoly('x').factor()
+ (x + zeta6 + 1)^2
+ sage: S.q_expansion_basis(10)
+ [
+ q + (-zeta6 - 1)*q^2 + (2*zeta6 - 2)*q^3 + zeta6*q^4 + (-2*zeta6 + 1)*q^5
+ + (-2*zeta6 + 4)*q^6 + (2*zeta6 - 1)*q^8 - zeta6*q^9 + O(q^10)
+ ]
+
+Aqui está um outro exemplo de como o Sage pode calcular a ação de
+operadores de Hecke em um espaço de formas modulares.
+
+::
+
+ sage: T = ModularForms(Gamma0(11),2)
+ sage: T
+ Modular Forms space of dimension 2 for Congruence Subgroup Gamma0(11) of
+ weight 2 over Rational Field
+ sage: T.degree()
+ 2
+ sage: T.level()
+ 11
+ sage: T.group()
+ Congruence Subgroup Gamma0(11)
+ sage: T.dimension()
+ 2
+ sage: T.cuspidal_subspace()
+ Cuspidal subspace of dimension 1 of Modular Forms space of dimension 2 for
+ Congruence Subgroup Gamma0(11) of weight 2 over Rational Field
+ sage: T.eisenstein_subspace()
+ Eisenstein subspace of dimension 1 of Modular Forms space of dimension 2
+ for Congruence Subgroup Gamma0(11) of weight 2 over Rational Field
+ sage: M = ModularSymbols(11); M
+ Modular Symbols space of dimension 3 for Gamma_0(11) of weight 2 with sign
+ 0 over Rational Field
+ sage: M.weight()
+ 2
+ sage: M.basis()
+ ((1,0), (1,8), (1,9))
+ sage: M.sign()
+ 0
+
+Denote por :math:`T_p` os operadores de Hecke usuais (:math:`p`
+primo). Como os operadores de Hecke :math:`T_2`, :math:`T_3`,
+e :math:`T_5` agem sobre o espaço de símbolos modulares?
+
+
+.. link
+
+::
+
+ sage: M.T(2).matrix()
+ [ 3 0 -1]
+ [ 0 -2 0]
+ [ 0 0 -2]
+ sage: M.T(3).matrix()
+ [ 4 0 -1]
+ [ 0 -1 0]
+ [ 0 0 -1]
+ sage: M.T(5).matrix()
+ [ 6 0 -1]
+ [ 0 1 0]
+ [ 0 0 1]
diff --git a/doc/pt/tutorial/tour_algebra.rst b/doc/pt/tutorial/tour_algebra.rst
new file mode 100644
--- /dev/null
+++ b/doc/pt/tutorial/tour_algebra.rst
@@ -0,0 +1,414 @@
+Álgebra Elementar e Cálculo
+===========================
+
+O Sage pode realizar diversos cálculos em álgebra elementar e cálculo
+diferencial e integral: por exemplo, encontrar soluções de equações,
+diferenciar, integrar, e calcular a transformada de Laplace. Veja a
+documentação em `Sage Constructions
+<http://www.sagemath.org/doc/constructions/>`_ para mais exemplos.
+
+Resolvendo equações
+-------------------
+
+Resolvendo equações exatamente
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+A função ``solve`` resolve equações. Para usá-la, primeiro especifique
+algumas variáveis; então os argumentos de ``solve`` são uma equação
+(ou um sistema de equações), juntamente com as variáveis para as
+quais resolver:
+
+::
+
+ sage: x = var('x')
+ sage: solve(x^2 + 3*x + 2, x)
+ [x == -2, x == -1]
+
+Você pode resolver equações para uma variável em termos das outras:
+
+::
+
+ sage: x, b, c = var('x b c')
+ sage: solve([x^2 + b*x + c == 0],x)
+ [x == -1/2*b - 1/2*sqrt(b^2 - 4*c), x == -1/2*b + 1/2*sqrt(b^2 - 4*c)]
+
+Você pode resolver para diversas variáveis:
+
+::
+
+ sage: x, y = var('x, y')
+ sage: solve([x+y==6, x-y==4], x, y)
+ [[x == 5, y == 1]]
+
+O seguinte exemplo, que mostra como usar o Sage para resolver um
+sistema de equações não-lineares, foi sugerido por Jason Grout:
+primeiro, resolvemos o sistemas simbolicamente:
+
+::
+
+ sage: var('x y p q')
+ (x, y, p, q)
+ sage: eq1 = p+q==9
+ sage: eq2 = q*y+p*x==-6
+ sage: eq3 = q*y^2+p*x^2==24
+ sage: solve([eq1,eq2,eq3,p==1],p,q,x,y)
+ [[p == 1, q == 8, x == -4/3*sqrt(10) - 2/3, y == 1/6*sqrt(2)*sqrt(5) - 2/3],
+ [p == 1, q == 8, x == 4/3*sqrt(10) - 2/3, y == -1/6*sqrt(2)*sqrt(5) - 2/3]]
+
+Para obter soluções numéricas aproximadas, podemos usar:
+
+.. link
+
+::
+
+ sage: solns = solve([eq1,eq2,eq3,p==1],p,q,x,y, solution_dict=True)
+ sage: [[s[p].n(30), s[q].n(30), s[x].n(30), s[y].n(30)] for s in solns]
+ [[1.0000000, 8.0000000, -4.8830369, -0.13962039],
+ [1.0000000, 8.0000000, 3.5497035, -1.1937129]]
+
+(A função ``n`` imprime uma aproximação numérica, e o argumento é o
+número de bits de precisão.)
+
+Resolvendo Equações Numericamente
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Frequentemente, ``solve`` não será capaz de encontrar uma solução
+exata para uma equação ou sistema de equações. Nesse caso, você pode
+usar ``find_root`` para encontrar uma solução numérica. Por exemplo,
+``solve`` não encontra uma solução para a equação abaixo::
+
+ sage: theta = var('theta')
+ sage: solve(cos(theta)==sin(theta), theta)
+ [sin(theta) == cos(theta)]
+
+Por outro lado, podemos usar ``find_root`` para encontrar uma solução
+para a equação acima no intervalo :math:`0 < \phi < \pi/2`::
+
+ sage: phi = var('phi')
+ sage: find_root(cos(phi)==sin(phi),0,pi/2)
+ 0.785398163397448...
+
+Diferenciação, Integração, etc.
+-------------------------------
+
+O Sage é capaz de diferenciar e integrar diversas funções. Por
+exemplo, para diferenciar :math:`\sin(u)` com respeito a :math:`u`,
+faça o seguinte:
+
+::
+
+ sage: u = var('u')
+ sage: diff(sin(u), u)
+ cos(u)
+
+Para calcular a quarta derivada de :math:`\sin(x^2)`:
+
+::
+
+ sage: diff(sin(x^2), x, 4)
+ 16*x^4*sin(x^2) - 48*x^2*cos(x^2) - 12*sin(x^2)
+
+Para calcular as derivadas parciais de :math:`x^2+17y^2` com respeito
+a *x* e *y*, respectivamente:
+
+::
+
+ sage: x, y = var('x,y')
+ sage: f = x^2 + 17*y^2
+ sage: f.diff(x)
+ 2*x
+ sage: f.diff(y)
+ 34*y
+
+Passamos agora para integrais, tanto indefinidas como definidas. Para
+calcular :math:`\int x\sin(x^2)\, dx` e :math:`\int_0^1
+\frac{x}{x^2+1}\, dx`:
+
+::
+
+ sage: integral(x*sin(x^2), x)
+ -1/2*cos(x^2)
+ sage: integral(x/(x^2+1), x, 0, 1)
+ 1/2*log(2)
+
+Para calcular a decomposição em frações parciais de
+:math:`\frac{1}{x^2-1}`:
+
+::
+
+ sage: f = 1/((1+x)*(x-1))
+ sage: f.partial_fraction(x)
+ 1/2/(x - 1) - 1/2/(x + 1)
+
+.. _section-systems:
+
+Resolvendo Equações Diferenciais
+--------------------------------
+
+Você pode usar o Sage para investigar equações diferenciais
+ordinárias. Para resolver a equação :math:`x'+x-1=0`:
+
+::
+
+ sage: t = var('t') # define a variable t
+ sage: x = function('x',t) # define x to be a function of that variable
+ sage: DE = diff(x, t) + x - 1
+ sage: desolve(DE, [x,t])
+ (c + e^t)*e^(-t)
+
+Esse método usa a interface do Sage para o Maxima [Max]_. Logo, o
+formato dos resultados é um pouco diferente de outros cálculos
+realizados no Sage. Nesse caso, o resultado diz que a solução geral da
+equação diferencial é :math:`x(t) = e^{-t}(e^{t}+c)`.
+
+Você pode calcular a transformada de Laplace também; a transformada de
+Laplace de :math:`t^2e^t -\sin(t)` é calculada da seguinte forma:
+
+::
+
+ sage: s = var("s")
+ sage: t = var("t")
+ sage: f = t^2*exp(t) - sin(t)
+ sage: f.laplace(t,s)
+ 2/(s - 1)^3 - 1/(s^2 + 1)
+
+A seguir, um exemplo mais complicado. O deslocamento, com respeito à
+posição de equilíbrio, de duas massas presas a uma parede através de
+molas, conforme a figura abaixo,
+
+::
+
+ |------\/\/\/\/\---|massa1|----\/\/\/\/\/----|massa2|
+ mola1 mola2
+
+é modelado pelo sistema de equações diferenciais de segunda ordem
+
+.. math::
+
+ m_1 x_1'' + (k_1+k_2) x_1 - k_2 x_2 = 0
+
+ m_2 x_2''+ k_2 (x_2-x_1) = 0,
+
+
+
+onde, para :math:`i=1,2`, :math:`m_{i}` é a massa do objeto *i*,
+:math:`x_{i}` é o deslocamento com respeito à posição de equilíbrio da
+massa *i*, e :math:`k_{i}` é a constante de mola para a mola *i*.
+
+**Exemplo:** Use o Sage para resolver o problema acima com
+:math:`m_{1}=2`, :math:`m_{2}=1`, :math:`k_{1}=4`,
+:math:`k_{2}=2`, :math:`x_{1}(0)=3`, :math:`x_{1}'(0)=0`,
+:math:`x_{2}(0)=3`, :math:`x_{2}'(0)=0`.
+
+Solução: Primeiramente, calcule a transformada de Laplace da primeira
+equação (usando a notação :math:`x=x_{1}`, :math:`y=x_{2}`):
+
+::
+
+ sage: de1 = maxima("2*diff(x(t),t, 2) + 6*x(t) - 2*y(t)")
+ sage: lde1 = de1.laplace("t","s"); lde1
+ 2*(-?%at('diff(x(t),t,1),t=0)+s^2*'laplace(x(t),t,s)-x(0)*s)-2*'laplace(y(t),t,s)+6*'laplace(x(t),t,s)
+
+O resultado é um pouco difícil de ler, mas diz que
+
+.. math:: -2x'(0) + 2s^2*X(s) - 2sx(0) - 2Y(s) + 6X(s) = 0
+
+
+(onde a transformada de Laplace de uma função em letra minúscula
+:math:`x(t)` é a função em letra maiúscula :math:`X(s)`). Agora,
+calcule a transformada de Laplace da segunda equação:
+
+::
+
+ sage: de2 = maxima("diff(y(t),t, 2) + 2*y(t) - 2*x(t)")
+ sage: lde2 = de2.laplace("t","s"); lde2
+ -?%at('diff(y(t),t,1),t=0)+s^2*'laplace(y(t),t,s)+2*'laplace(y(t),t,s)-2*'laplace(x(t),t,s)-y(0)*s
+
+O resultado significa que
+
+.. math:: -Y'(0) + s^2Y(s) + 2Y(s) - 2X(s) - sy(0) = 0.
+
+
+Em seguida, substitua a condição inicial para :math:`x(0)`,
+:math:`x'(0)`, :math:`y(0)`, e :math:`y'(0)`, e resolva as equações
+resultantes:
+
+::
+
+ sage: var('s X Y')
+ (s, X, Y)
+ sage: eqns = [(2*s^2+6)*X-2*Y == 6*s, -2*X +(s^2+2)*Y == 3*s]
+ sage: solve(eqns, X,Y)
+ [[X == 3*(s^3 + 3*s)/(s^4 + 5*s^2 + 4),
+ Y == 3*(s^3 + 5*s)/(s^4 + 5*s^2 + 4)]]
+
+Agora calcule a transformada de Laplace inversa para obter a resposta:
+
+::
+
+ sage: var('s t')
+ (s, t)
+ sage: inverse_laplace((3*s^3 + 9*s)/(s^4 + 5*s^2 + 4),s,t)
+ cos(2*t) + 2*cos(t)
+ sage: inverse_laplace((3*s^3 + 15*s)/(s^4 + 5*s^2 + 4),s,t)
+ -cos(2*t) + 4*cos(t)
+
+Portanto, a solução é
+
+.. math:: x_1(t) = \cos(2t) + 2\cos(t), \quad x_2(t) = 4\cos(t) - \cos(2t).
+
+
+Ela pode ser representada em um gráfico parametricamente usando os
+comandos
+
+::
+
+ sage: t = var('t')
+ sage: P = parametric_plot((cos(2*t) + 2*cos(t), 4*cos(t) - cos(2*t) ),\
+ ... (t, 0, 2*pi), rgbcolor=hue(0.9))
+ sage: show(P)
+
+As componentes individuais podem ser representadas em gráfico usando
+
+::
+
+ sage: t = var('t')
+ sage: p1 = plot(cos(2*t) + 2*cos(t), (t,0, 2*pi), rgbcolor=hue(0.3))
+ sage: p2 = plot(4*cos(t) - cos(2*t), (t,0, 2*pi), rgbcolor=hue(0.6))
+ sage: show(p1 + p2)
+
+Leia mais sobre gráficos em :ref:`section-plot`. Veja a seção 5.5 de
+[NagleEtAl2004]_ (em inglês) para mais informações sobre equações
+diferenciais.
+
+
+Método de Euler para Sistemas de Equações Diferenciais
+------------------------------------------------------
+
+No próximo exemplo, vamos ilustrar o método de Euler para EDOs de
+primeira e segunda ordem. Primeiro, relembramos a ideia básica para
+equações de primeira ordem. Dado um problema de valor inicial da forma
+
+.. math::
+
+ y'=f(x,y), \quad y(a)=c,
+
+queremos encontrar o valor aproximado da solução em :math:`x=b` com
+:math:`b>a`.
+
+Da definição de derivada segue que
+
+.. math:: y'(x) \approx \frac{y(x+h)-y(x)}{h},
+
+
+onde :math:`h>0` é um número pequeno. Isso, juntamente com a equação
+diferencial, implica que :math:`f(x,y(x))\approx
+\frac{y(x+h)-y(x)}{h}`. Agora resolvemos para :math:`y(x+h)`:
+
+.. math:: y(x+h) \approx y(x) + h*f(x,y(x)).
+
+
+Se chamarmos :math:`h f(x,y(x))` de "termo de correção", :math:`y(x)`
+de "valor antigo de *y*", e :math:`y(x+h)` de "novo valor de *y*",
+então essa aproximação pode ser reescrita como
+
+.. math:: y_{novo} \approx y_{antigo} + h*f(x,y_{antigo}).
+
+
+Se dividirmos o intervalo de *a* até *b* em *n* partes, de modo que
+:math:`h=\frac{b-a}{n}`, então podemos construir a seguinte tabela.
+
+============== ================== ================
+:math:`x` :math:`y` :math:`hf(x,y)`
+============== ================== ================
+:math:`a` :math:`c` :math:`hf(a,c)`
+:math:`a+h` :math:`c+hf(a,c)` ...
+:math:`a+2h` ...
+...
+:math:`b=a+nh` ??? ...
+============== ================== ================
+
+
+O objetivo é completar os espaços em branco na tabela, em uma linha
+por vez, até atingirmos ???, que é a aproximação para :math:`y(b)`
+usando o método de Euler.
+
+A ideia para sistemas de EDOs é semelhante.
+
+**Exemplo:** Aproxime numericamente :math:`z(t)` em :math:`t=1` usando
+4 passos do método de Euler, onde :math:`z''+tz'+z=0`, :math:`z(0)=1`,
+:math:`z'(0)=0`.
+
+Devemos reduzir a EDO de segunda ordem a um sistema de duas EDOs de
+primeira ordem (usando :math:`x=z`, :math:`y=z'`) e aplicar o método
+de Euler:
+
+::
+
+ sage: t,x,y = PolynomialRing(RealField(10),3,"txy").gens()
+ sage: f = y; g = -x - y * t
+ sage: eulers_method_2x2(f,g, 0, 1, 0, 1/4, 1)
+ t x h*f(t,x,y) y h*g(t,x,y)
+ 0 1 0.00 0 -0.25
+ 1/4 1.0 -0.062 -0.25 -0.23
+ 1/2 0.94 -0.12 -0.48 -0.17
+ 3/4 0.82 -0.16 -0.66 -0.081
+ 1 0.65 -0.18 -0.74 0.022
+
+Portanto, :math:`z(1)\approx 0.65`.
+
+Podemos também representar em um gráfico os pontos :math:`(x,y)` para
+obter uma figura da solução aproximada. A função
+``eulers_method_2x2_plot`` fará isso; para usá-la, precisamos definir
+funções *f* e *g* que recebam um argumento com três coordenadas (*t*,
+*x*, *y*).
+
+::
+
+ sage: f = lambda z: z[2] # f(t,x,y) = y
+ sage: g = lambda z: -sin(z[1]) # g(t,x,y) = -sin(x)
+ sage: P = eulers_method_2x2_plot(f,g, 0.0, 0.75, 0.0, 0.1, 1.0)
+
+A esta altura, ``P`` armazena dois gráficos: ``P[0]``, o gráfico de
+*x* versus *t*, e ``P[1]``, o gráfico de *y* versus *t*. Podemos
+visualizar os dois gráficos da seguinte forma:
+
+.. link
+
+::
+
+ sage: show(P[0] + P[1])
+
+(Para mais sobre gráficos, veja :ref:`section-plot`.)
+
+Funções Especiais
+-----------------
+
+Diversos polinômios ortogonais e funções especiais estão
+implementadas, usando tanto o PARI [GP]_ como o Maxima [Max]_. Isso
+está documentado nas seções apropriadas ("Orthogonal polynomials" and
+"Special functions", respectivamente) do manual de referência do Sage
+(em inglês).
+
+::
+
+ sage: x = polygen(QQ, 'x')
+ sage: chebyshev_U(2,x)
+ 4*x^2 - 1
+ sage: bessel_I(1,1,"pari",250)
+ 0.56515910399248502720769602760986330732889962162109200948029448947925564096
+ sage: bessel_I(1,1)
+ 0.565159103992485
+ sage: bessel_I(2,1.1,"maxima") # last few digits are random
+ 0.16708949925104899
+
+No momento, essas funções estão disponíveis na interface do Sage
+apenas para uso numérico. Para uso simbólico, use a interface do
+Maxima diretamente, como no seguinte exemplo:
+
+::
+
+ sage: maxima.eval("f:bessel_y(v, w)")
+ 'bessel_y(v,w)'
+ sage: maxima.eval("diff(f,w)")
+ '(bessel_y(v-1,w)-bessel_y(v+1,w))/2'
diff --git a/doc/pt/tutorial/tour_assignment.rst b/doc/pt/tutorial/tour_assignment.rst
new file mode 100644
--- /dev/null
+++ b/doc/pt/tutorial/tour_assignment.rst
@@ -0,0 +1,119 @@
+Atribuição, Igualdade, e Aritmética
+===================================
+
+Com pequenas exceções, o Sage utiliza a linguagem de programação
+Python, logo a maioria dos livros de introdução ao Python vão ajudá-lo
+a aprender Sage.
+
+O Sage usa ``=`` para atribuição, e usa ``==``, ``<=``, ``>=``, ``<``
+e ``>`` para comparação:
+
+::
+
+ sage: a = 5
+ sage: a
+ 5
+ sage: 2 == 2
+ True
+ sage: 2 == 3
+ False
+ sage: 2 < 3
+ True
+ sage: a == 5
+ True
+
+O Sage fornece todas as operações matemáticas básicas:
+
+::
+
+ sage: 2**3 # ** means exponent
+ 8
+ sage: 2^3 # ^ is a synonym for ** (unlike in Python)
+ 8
+ sage: 10 % 3 # for integer arguments, % means mod, i.e., remainder
+ 1
+ sage: 10/4
+ 5/2
+ sage: 10//4 # for integer arguments, // returns the integer quotient
+ 2
+ sage: 4 * (10 // 4) + 10 % 4 == 10
+ True
+ sage: 3^2*4 + 2%5
+ 38
+
+O cálculo de uma expressão como ``3^2*4 + 2%5`` depende da ordem em
+que as operações são aplicadas; isso é especificado na "tabela de
+precedência" em :ref:`section-precedence`.
+
+O Sage também fornece várias funções matemáticas básicas; aqui estão
+apenas alguns exemplos:
+
+::
+
+ sage: sqrt(3.4)
+ 1.84390889145858
+ sage: sin(5.135)
+ -0.912021158525540
+ sage: sin(pi/3)
+ 1/2*sqrt(3)
+
+Como o último exemplo mostra, algumas expressões matemáticas retornam
+valores 'exatos' em vez de aproximações numéricas. Para obter uma
+aproximação numérica, use a função ``n`` ou o método ``n`` (ambos
+possuem um nome longo, ``numerical_approx``, e a função ``N`` é o
+mesma que ``n``). Essas funções aceitam o argumento opcional
+``prec``, que é o número de bits de precisão requisitado, e
+``digits``, que é o número de dígitos decimais de precisão
+requisitado; o padrão é 53 bits de precisão.
+
+::
+
+ sage: exp(2)
+ e^2
+ sage: n(exp(2))
+ 7.38905609893065
+ sage: sqrt(pi).numerical_approx()
+ 1.77245385090552
+ sage: sin(10).n(digits=5)
+ -0.54402
+ sage: N(sin(10),digits=10)
+ -0.5440211109
+ sage: numerical_approx(pi, prec=200)
+ 3.1415926535897932384626433832795028841971693993751058209749
+
+O Python é uma linguagem "dinâmicamente digitada" (dynamically typed),
+portanto o valor referido por cada variável possui um tipo associado a
+ele, mas uma variável pode possuir valores de qualquer tipo em
+determinado escopo:
+
+::
+
+ sage: a = 5 # a is an integer
+ sage: type(a)
+ <type 'sage.rings.integer.Integer'>
+ sage: a = 5/3 # now a is a rational number
+ sage: type(a)
+ <type 'sage.rings.rational.Rational'>
+ sage: a = 'hello' # now a is a string
+ sage: type(a)
+ <type 'str'>
+
+A linguagem de programação C, que é "estaticamente digitada"
+(statically typed), é muito diferente; uma variável que foi declarada
+como int pode apenas armazenar um int em seu escopo.
+
+Uma potencial fonte de confusão em Python é que um inteiro literal que
+começa com zero é tratado como um número octal, isto é, um número na
+base 8.
+
+::
+
+ sage: 011
+ 9
+ sage: 8 + 1
+ 9
+ sage: n = 011
+ sage: n.str(8) # string representation of n in base 8
+ '11'
+
+Isso é consistente com a linguagem de programação C.
diff --git a/doc/pt/tutorial/tour_coercion.rst b/doc/pt/tutorial/tour_coercion.rst
new file mode 100644
--- /dev/null
+++ b/doc/pt/tutorial/tour_coercion.rst
@@ -0,0 +1,405 @@
+.. -*- coding: utf-8 -*-
+
+.. _section-coercion:
+
+============================
+Parentes, Conversão e Coação
+============================
+
+Esta seção pode parecer mais técnica do que as anteriores, mas
+acreditamos que é importante entender o significado de parentes e
+coação de modo a usar anéis e outras estruturas algébricas no Sage de
+forma efetiva e eficiente.
+
+Note que vamos explicar algumas noções, mas não vamos mostrar aqui
+como implementá-las. Um tutorial voltado à implementação está
+disponível (em inglês) como um
+`arquivo Sage <http://flask.sagenb.org/home/pub/82/>`_.
+
+Elementos
+---------
+
+Caso se queira implementar um anel em Python, uma primeira aproximação
+seria criar uma classe para os elementos ``X`` do anel e adicionar os
+requeridos métodos (com underscores duplos) ``__add__``, ``__sub``,
+``__mul__``, obviamente garantindo que os axiomas de anel são
+verificados.
+
+Como o Python é uma linguagem "strongly typed" (ainda que "dynamically
+typed"), poderia-se, pelo menos a princípio, esperar-se que fosse
+implementado em Python uma classe para cada anel. No final das contas,
+o Python contém um tipo ``<int>`` para os inteiros, um tipo
+``<float>`` para os reais, e assim por diante. Mas essa estratégia
+logo encontra uma limitação: Existe um número infinito de anéis, e não
+se pode implementar um número infinito de classes.
+
+Em vez disso, poderia-se criar uma hierarquia de classes projetada
+para implementar elementos de estruturas algébricas ubíquas, tais como
+grupos, anéis, anéis comutativos, corpos, álgebras, e assim por
+diante.
+
+Mas isso significa que elementos de anéis bastante diferentes podem
+ter o mesmo tipo.
+
+::
+
+ sage: P.<x,y> = GF(3)[]
+ sage: Q.<a,b> = GF(4,'z')[]
+ sage: type(x)==type(a)
+ True
+
+Por outro lado, poderia-se ter também classes diferentes em Python
+fornecendo implementações diferentes da mesma estrutura matemática
+(por exemplo, matrizes densas versus matrizes esparsas).
+
+::
+
+ sage: P.<a> = PolynomialRing(ZZ)
+ sage: Q.<b> = PolynomialRing(ZZ, sparse=True)
+ sage: R.<c> = PolynomialRing(ZZ, implementation='NTL')
+ sage: type(a); type(b); type(c)
+ <type 'sage.rings.polynomial.polynomial_integer_dense_flint.Polynomial_integer_dense_flint'>
+ <class 'sage.rings.polynomial.polynomial_element_generic.Polynomial_generic_sparse'>
+ <type 'sage.rings.polynomial.polynomial_integer_dense_ntl.Polynomial_integer_dense_ntl'>
+
+Isso apresenta dois problemas: Por um lado, se tivéssemos elementos
+que são duas instancias da mesma classe, então poderia-se esperar que
+o método ``__add__`` dessas classes permitisse somá-los; mas não
+se deseja isso, se os elementos pertencem a anéis bastante diferentes.
+Por outro lado, se possui-se elementos que pertencem a implementações
+diferentes do mesmo anel, então gostaria-se de somá-los, mas isso não
+pode ser feito diretamente se eles pertencem a classes diferentes em
+Python.
+
+A solução para esses problemas é chamada coação e será explicada a
+seguir.
+
+Todavia, é essencial que cada elemento saiba a qual pertence. Isso
+está disponível através método ``parent()``:
+
+.. link
+
+::
+
+ sage: a.parent(); b.parent(); c.parent()
+ Univariate Polynomial Ring in a over Integer Ring
+ Sparse Univariate Polynomial Ring in b over Integer Ring
+ Univariate Polynomial Ring in c over Integer Ring (using NTL)
+
+
+Parentes e Categorias
+---------------------
+
+De forma similar à hierarquia de classes em Python voltada para
+elementos de estruturas algébricas, o Sage também fornece classes para
+as estruturas algébricas que contém esses elementos. Estruturas
+contendo elementos são chamadas "estruturas parente" no Sage, e existe
+uma classe básica para elas. Paralelamente à hierarquia de noções
+matemáticas, tem-se uma hierarquia de classes, a saber, para
+conjuntos, anéis, corpos e assim por diante:
+
+::
+
+ sage: isinstance(QQ,Field)
+ True
+ sage: isinstance(QQ, Ring)
+ True
+ sage: isinstance(ZZ,Field)
+ False
+ sage: isinstance(ZZ, Ring)
+ True
+
+Em álgebra, objetos que compartilham o mesmo tipo de estruturas
+algébricas são agrupados nas assim chamadas "categorias". Logo, existe
+uma analogia aproximada entre a hierarquia de classes em Sage e a
+hierarquia de categorias. Todavia, essa analogia de classes em Python
+e categorias não deve ser enfatizada demais. No final das contas,
+categorias matemáticas também são implementadas no Sage:
+
+::
+
+ sage: Rings()
+ Category of rings
+ sage: ZZ.category()
+ Category of euclidean domains
+ sage: ZZ.category().is_subcategory(Rings())
+ True
+ sage: ZZ in Rings()
+ True
+ sage: ZZ in Fields()
+ False
+ sage: QQ in Fields()
+ True
+
+Enquanto a hierarquia de classes no Sage é centrada nos detalhes de
+implementação, a construção de categorias em Sage é mais centrada
+na estrutura matemática. É possível implementar métodos e testes
+gerais independentemente de uma implementação específica nas
+categorias.
+
+Estruturas parentes em Sage são supostamente objetos únicos em Python.
+Por exemplo, uma vez que um anel de polinômios sobre um certo anel
+base e com uma certa lista de geradores é criada, o resultado é
+arquivado:
+
+::
+
+ sage: RR['x','y'] is RR['x','y']
+ True
+
+
+Tipos versus Parentes
+---------------------
+
+O tipo ``RingElement`` não deve ser confundido com a noção matemática
+de elemento de anel; por razões práticas, as vezes um objeto é uma
+instancia de ``RingElement`` embora ele não pertence a um anel:
+
+::
+
+ sage: M = Matrix(ZZ,2,3); M
+ [0 0 0]
+ [0 0 0]
+ sage: isinstance(M, RingElement)
+ True
+
+Enquanto *parentes* são únicos, elementos iguais de um parente em Sage
+não são necessariamente idênticos. Isso contrasta com o comportamento
+do Python para alguns (embora não todos) inteiros:
+
+::
+
+ sage: int(1) is int(1) # Python int
+ True
+ sage: int(-15) is int(-15)
+ False
+ sage: 1 is 1 # Sage Integer
+ False
+
+É importante observar que elementos de anéis diferentes em geral não
+podem ser distinguidos pelos seus tipos, mas sim por seus parentes:
+
+::
+
+ sage: a = GF(2)(1)
+ sage: b = GF(5)(1)
+ sage: type(a) is type(b)
+ True
+ sage: parent(a)
+ Finite Field of size 2
+ sage: parent(b)
+ Finite Field of size 5
+
+Logo, de um ponto de vista algébrico, **o parente de um elemento é
+mais importante do que seu tipo.**
+
+Conversão versus Coação
+-----------------------
+
+Em alguns casos é possível converter um elemento de uma estrutura
+parente em um elemento de uma outra estrutura parente. Tal conversão
+pode ser tanto explícita como implícita (essa é chamada *coação*).
+
+O leitor pode conhecer as noções de *conversão de tipo* e *coação de
+tipo* como na linguagem C, por exemplo. Existem noções de *conversão*
+e *coação* em Sage também. Mas as noções em Sage são centradas em
+*parentes*, não em tipos. Então, por favor não confunda conversão de
+tipo em C com conversão em Sage!
+
+Aqui se encontra uma breve apresentação. Para uma descrição detalhada
+e informações sobre a implementação, referimos à seção sobre coação no
+manual de referência e para o `arquivo tutorial
+<http://flask.sagenb.org/home/pub/82/>`_.
+
+Existem duas possibilidades extremas com respeito à possibilidade de
+fazer aritmética com elementos de *anéis diferentes*:
+
+* Anéis diferentes são mundos diferentes, e não faz nenhum sentido
+ somar ou multiplicar elementos de anéis diferentes; mesmo ``1 +
+ 1/2`` não faz sentido, pois o primeiro somando é um inteiro e o
+ segundo um racional.
+
+Ou
+
+* Se um elemento ``r1`` de uma aner ``R1`` pode de alguma forma ser
+ interpretado em um outro anel ``R2``, então todas as operações
+ aritméticas envolvendo ``r1`` e qualquer elemento de ``R2`` são
+ permitidas. O elemento neutro da multiplicação existe em todos os
+ corpos e em vários anéis, e eles devem ser todos iguais.
+
+O Sage faz uma concessão. Se ``P1`` e ``P2`` são estruturas parentes e
+``p1`` é um elemento de ``P1``, então o usuário pode explicitamente
+perguntar por uma interpretação de ``p1`` em ``P2``. Isso pode não
+fazer sentido em todos os casos ou não estar definido para todos os
+elementos de ``P1``, e fica a cargo do usuário assegurar que isso faz
+sentido. Nos referimos a isso como **conversão**:
+
+::
+
+ sage: a = GF(2)(1)
+ sage: b = GF(5)(1)
+ sage: GF(5)(a) == b
+ True
+ sage: GF(2)(b) == a
+ True
+
+Todavia, uma conversão *implícita* (ou automática) ocorrerá apenas se
+puder ser feita *completamente* e *consistentemente*. Rigor matemático
+é essencial nesse ponto.
+
+Uma tal conversão implícita é chamada **coação**. Se coação for
+definida, então deve coincidir com conversão. Duas condições devem ser
+satisfeitas para uma coação ser definida:
+
+#. Uma coação de ``P1`` para ``P2`` deve ser dada por uma estrutura
+ que preserva mapeamentos (por exemplo, um homomorfismo de anéis).
+ Não é suficiente que *alguns* elementos de ``P1`` possam ser
+ mapeados em ``P2``, e o mapa deve respeitar a estrutura algébrica
+ de ``P1``.
+#. A escolha desses mapas de coação deve ser consistente: Se ``P3`` é
+ uma terceira estrutura parente, então a composição da coação
+ adotada de ``P1`` para ``P2`` com a coação de ``P2`` para ``P3``
+ deve coincidir com a coação adotada de ``P1`` para ``P3``. Em
+ particular, se existir uma coação de ``P1`` para ``P2`` e ``P2``
+ para ``P1``, a composição deve ser o mapa identidade em ``P1``.
+
+Logo, embora é possível converter cada elemento de ``GF(2)`` para
+``GF(5)``, não há coação, pois não existe homomorfismo de anel entre
+``GF(2)`` e ``GF(5)``.
+
+O segundo aspecto - consistência - é um pouco mais difícil de
+explicar. Vamos ilustrá-lo usando anéis de polinômios em mais de uma
+variável. Em aplicações, certamente faz mais sentido ter coações que
+preservam nomes. Então temos:
+
+::
+
+ sage: R1.<x,y> = ZZ[]
+ sage: R2 = ZZ['y','x']
+ sage: R2.has_coerce_map_from(R1)
+ True
+ sage: R2(x)
+ x
+ sage: R2(y)
+ y
+
+Se não existir homomorfismo de anel que preserve nomes, coerção não é
+definida. Todavia, conversão pode ainda ser possível, a saber,
+mapeando geradores de anel de acordo com sua posição da lista de
+geradores:
+
+.. link
+
+::
+
+ sage: R3 = ZZ['z','x']
+ sage: R3.has_coerce_map_from(R1)
+ False
+ sage: R3(x)
+ z
+ sage: R3(y)
+ x
+
+Mas essas conversões que preservam a posição não se qualificam como
+coação: Compondo um mapa que preserva nomes de ``ZZ['x','y']`` para
+``ZZ['y','x']``, com um mapa que preserva nomes de ``ZZ['y','x']``
+para ``ZZ['a','b']``, resultaria em um mapa que não preserva nomes nem
+posição, violando a consistência.
+
+Se houver coação, ela será usada para comparar elementos de anéis
+diferentes ou fazer aritmética. Isso é frequentemente conveniente, mas
+o usuário deve estar ciente que estender a relação ``==`` além das
+fronteiras de parentes diferentes pode facilmente resultar em
+problemas. Por exemplo, enquanto ``==`` é supostamente uma relação de
+equivalência sobre os elementos de *um* anel, isso não é
+necessariamente o caso se anéis *diferentes* estão envolvidos. Por
+exemplo, ``1`` em ``ZZ`` e em um corpo finito são considerados iguais,
+pois existe uma coação canônica dos inteiros em qualquer corpo finito.
+Todavia, em geral não existe coação entre dois corpos finitos
+diferentes. Portanto temos
+
+.. link
+
+::
+
+ sage: GF(5)(1) == 1
+ True
+ sage: 1 == GF(2)(1)
+ True
+ sage: GF(5)(1) == GF(2)(1)
+ False
+ sage: GF(5)(1) != GF(2)(1)
+ True
+
+Similarmente,
+
+.. link
+
+::
+
+ sage: R3(R1.1) == R3.1
+ True
+ sage: R1.1 == R3.1
+ False
+ sage: R1.1 != R3.1
+ True
+
+Uma outra consequência da condição de consistência é que coação pode
+apenas ir de anéis exatos (por exemplo, os racionais ``QQ``) para
+anéis não-exatos (por exemplo, os números reais com uma precisão fixa
+``RR``), mas não na outra direção. A razão é que a composição da
+coação de ``QQ`` em ``RR`` com a conversão de ``RR`` para ``QQ``
+deveria ser a identidade em ``QQ``. Mas isso é impossível, pois alguns
+números racionais distintos podem ser tratados como iguais em ``RR``,
+como no seguinte exemplo:
+
+::
+
+ sage: RR(1/10^200+1/10^100) == RR(1/10^100)
+ True
+ sage: 1/10^200+1/10^100 == 1/10^100
+ False
+
+Quando se compara elementos de dois parentes ``P1`` e ``P2``, é
+possível que não haja coação entre os dois anéis, mas existe uma
+escolha canônica de um parente ``P3`` de modo que tanto ``P1`` como
+``P2`` são coagidos em ``P3``. Nesse caso, coação vai ocorrer também.
+Um caso de uso típico é na soma de um número racional com um polinômio
+com coeficientes inteiros, resultando em um polinômio com coeficientes
+racionais:
+
+::
+
+ sage: P1.<x> = ZZ[]
+ sage: p = 2*x+3
+ sage: q = 1/2
+ sage: parent(p)
+ Univariate Polynomial Ring in x over Integer Ring
+ sage: parent(p+q)
+ Univariate Polynomial Ring in x over Rational Field
+
+Note que a princípio o resultado deveria também fazer sentido no
+corpo de frações de ``ZZ['x']``. Todavia, o Sage tenta escolher um
+parente *canônico* comum que parece ser o mais natural (``QQ['x']`` no
+nosso exemplo). Se vários potenciais parentes comuns parecem
+igualmente naturais, o Sage *não* vai escolher um deles
+aleatoriamente. Os mecanismos sobre os quais essa escolha se baseia é
+explicado em um `arquivo tutorial
+<http://flask.sagenb.org/home/pub/82/>`_
+
+Nenhuma coação para um parente comum vai ocorrer no seguinte exemplo:
+
+::
+
+ sage: R.<x> = QQ[]
+ sage: S.<y> = QQ[]
+ sage: x+y
+ Traceback (most recent call last):
+ ...
+ TypeError: unsupported operand parent(s) for '+': 'Univariate Polynomial Ring in x over Rational Field' and 'Univariate Polynomial Ring in y over Rational Field'
+
+A razão é que o Sage não escolhe um dos potenciais candidatos
+``QQ['x']['y']``, ``QQ['y']['x']``, ``QQ['x','y']`` ou
+``QQ['y','x']``, porque todas essas estruturas combinadas em pares
+diferentes parecem ser parentes comuns naturais, e não existe escolha
+canônica aparente.
diff --git a/doc/pt/tutorial/tour_functions.rst b/doc/pt/tutorial/tour_functions.rst
new file mode 100644
--- /dev/null
+++ b/doc/pt/tutorial/tour_functions.rst
@@ -0,0 +1,236 @@
+.. _section-functions-issues:
+
+Algumas Questões Frequentes sobre Funções
+=========================================
+
+Alguns aspectos sobre definição de funções (por exemplo, para
+diferenciação, ou para criar gráficos) podem se tornar confusos. Nesta
+seção, procuramos tratar algumas questões relevantes.
+
+Aqui estão várias formas de definir objetos que merecem ser chamamos
+de "funções":
+
+1. Defina uma função em Python, como descrito em
+:ref:`section-functions`. Essas funções podem ser usadas para criar
+gráficos, mas não podem ser diferenciadas ou integradas.
+
+::
+
+ sage: def f(z): return z^2
+ sage: type(f)
+ <type 'function'>
+ sage: f(3)
+ 9
+ sage: plot(f, 0, 2)
+
+Na última linha, observe a sintaxe. Se fosse usado ``plot(f(z), 0,
+2)`` ocorreria um erro, porque ``z`` é uma variável muda na definição
+de ``f`` e não está definida fora do contexto da função. De fato,
+somente ``f(z)`` já provoca um erro. Os seguintes comandos vão
+funcionar neste caso, embora em geral eles devam ser evitados pois
+podem ocasionar erros (veja o item 4 abaixo).
+
+.. link
+
+::
+
+ sage: var('z') # define z to be a variable
+ z
+ sage: f(z)
+ z^2
+ sage: plot(f(z), 0, 2)
+
+Acima, ``f(z)`` é uma expressão simbólica, o próximo item na nossa
+lista.
+
+2. Defina um "expressão simbólica que pode ser evocada". Essas podem
+ser usadas para criar gráficos, e podem ser diferenciadas ou
+integradas.
+
+::
+
+ sage: g(x) = x^2
+ sage: g # g sends x to x^2
+ x |--> x^2
+ sage: g(3)
+ 9
+ sage: Dg = g.derivative(); Dg
+ x |--> 2*x
+ sage: Dg(3)
+ 6
+ sage: type(g)
+ <type 'sage.symbolic.expression.Expression'>
+ sage: plot(g, 0, 2)
+
+Note que enquanto ``g`` é uma expressão simbólica que pode ser
+evocada, ``g(x)`` é um objeto diferente, embora relacionado, que pode
+ser usado para criar gráficos, ou ser diferenciado, integrado, etc.,
+embora com algumas ressalvas: veja o item 5 abaixo.
+
+.. link
+
+::
+
+ sage: g(x)
+ x^2
+ sage: type(g(x))
+ <type 'sage.symbolic.expression.Expression'>
+ sage: g(x).derivative()
+ 2*x
+ sage: plot(g(x), 0, 2)
+
+3. Use uma função pré-definida. Essas podem ser representadas em
+gráfico, e com uma pequena ajuda, diferenciadas e integradas.
+
+::
+
+ sage: type(sin)
+ <class 'sage.functions.trig.Function_sin'>
+ sage: plot(sin, 0, 2)
+ sage: type(sin(x))
+ <type 'sage.symbolic.expression.Expression'>
+ sage: plot(sin(x), 0, 2)
+
+Por si só, ``sin`` não pode ser diferenciado, pelo menos não para
+produzir ``cos``.
+
+::
+
+ sage: f = sin
+ sage: f.derivative()
+ Traceback (most recent call last):
+ ...
+ AttributeError: ...
+
+Usando ``f = sin(x)`` no lugar de ``sin`` funciona, mas é ainda melhor
+usar ``f(x) = sin(x)`` para definir uma expressão simbólica que pode
+ser evocada.
+
+::
+
+ sage: S(x) = sin(x)
+ sage: S.derivative()
+ x |--> cos(x)
+
+Aqui estão alguns problemas comuns, com explicações:
+
+\4. Cálculo acidental.
+
+::
+
+ sage: def h(x):
+ ... if x<2:
+ ... return 0
+ ... else:
+ ... return x-2
+
+O problema: ``plot(h(x), 0, 4)`` cria o gráfico da reta `y=x-2`, não
+da função definida por ``h``. O motivo? No comando ``plot(h(x), 0,
+4)``, primeiro ``h(x)`` é calculada: isso significa substituir ``x``
+na função ``h``, o que significa que ``x<2`` é calculado.
+
+.. link
+
+::
+
+ sage: type(x<2)
+ <type 'sage.symbolic.expression.Expression'>
+
+Quando uma equação simbólica é calculada, como na definição de ``h``,
+se ela não é obviamente verdadeira, então ela retorna False. Logo
+``h(x)`` é calculada como ``x-2``, e essa é a função que será
+representada no gráfico.
+
+A solução: não use ``plot(h(x), 0, 4)``; em vez disso, use
+
+.. link
+
+::
+
+ sage: plot(h, 0, 4)
+
+\5. Acidentalmente produzindo uma constante em vez de uma função.
+
+::
+
+ sage: f = x
+ sage: g = f.derivative()
+ sage: g
+ 1
+
+O problema: ``g(3)``, por exemplo, retorna o erro "ValueError: the
+number of arguments must be less than or equal to 0."
+
+.. link
+
+::
+
+ sage: type(f)
+ <type 'sage.symbolic.expression.Expression'>
+ sage: type(g)
+ <type 'sage.symbolic.expression.Expression'>
+
+``g`` não é uma função, é uma constante, logo não possui variáveis
+associadas, e você não pode substituir nenhum valor em ``g``.
+
+Solução: existem vária opções.
+
+- Defina ``f`` inicialmente como uma expressão simbólica.
+
+::
+
+ sage: f(x) = x # instead of 'f = x'
+ sage: g = f.derivative()
+ sage: g
+ x |--> 1
+ sage: g(3)
+ 1
+ sage: type(g)
+ <type 'sage.symbolic.expression.Expression'>
+
+- Ou com ``f`` como definida originalmente, defina ``g`` como uma
+ expressão simbólica.
+
+::
+
+ sage: f = x
+ sage: g(x) = f.derivative() # instead of 'g = f.derivative()'
+ sage: g
+ x |--> 1
+ sage: g(3)
+ 1
+ sage: type(g)
+ <type 'sage.symbolic.expression.Expression'>
+
+- Ou com ``f`` e ``g`` como definidas originalmente, especifique a
+ variável para a qual você está substituindo.
+
+::
+
+ sage: f = x
+ sage: g = f.derivative()
+ sage: g
+ 1
+ sage: g(x=3) # instead of 'g(3)'
+ 1
+
+Finalmente, aqui vai mais uma forma de saber a diferença entre as
+derivadas de ``f = x`` e ``f(x) = x``.
+
+::
+
+ sage: f(x) = x
+ sage: g = f.derivative()
+ sage: g.variables() # the variables present in g
+ ()
+ sage: g.arguments() # the arguments which can be plugged into g
+ (x,)
+ sage: f = x
+ sage: h = f.derivative()
+ sage: h.variables()
+ ()
+ sage: h.arguments()
+ ()
+
+Como esse exemplo procura ilustrar, ``h`` não aceita argumentos, e é
+por isso que ``h(3)`` retorna um erro.
diff --git a/doc/pt/tutorial/tour_groups.rst b/doc/pt/tutorial/tour_groups.rst
new file mode 100644
--- /dev/null
+++ b/doc/pt/tutorial/tour_groups.rst
@@ -0,0 +1,92 @@
+Grupos Finitos, Grupos Abelianos
+================================
+
+O Sage possui suporte para fazer cálculos com grupos de permutação,
+grupos finitos clássicos (tais como :math:`SU(n,q)`), grupos
+matriciais finitos (com os seus próprios geradores), e grupos
+abelianos (até mesmo infinitos). A maior parte disso é implementada
+usando a interface com o GAP.
+
+Por exemplo, para criar um grupo de permutação, forneça uma lista de
+geradores, como no seguinte exemplo.
+
+::
+
+ sage: G = PermutationGroup(['(1,2,3)(4,5)', '(3,4)'])
+ sage: G
+ Permutation Group with generators [(3,4), (1,2,3)(4,5)]
+ sage: G.order()
+ 120
+ sage: G.is_abelian()
+ False
+ sage: G.derived_series() # random-ish output
+ [Permutation Group with generators [(1,2,3)(4,5), (3,4)],
+ Permutation Group with generators [(1,5)(3,4), (1,5)(2,4), (1,3,5)]]
+ sage: G.center()
+ Subgroup of (Permutation Group with generators [(3,4), (1,2,3)(4,5)]) generated by [()]
+ sage: G.random_element() # random output
+ (1,5,3)(2,4)
+ sage: print latex(G)
+ \langle (3,4), (1,2,3)(4,5) \rangle
+
+Você pode também obter a tabela de caracteres (em formato LaTeX) no
+Sage:
+
+::
+
+ sage: G = PermutationGroup([[(1,2),(3,4)], [(1,2,3)]])
+ sage: latex(G.character_table())
+ \left(\begin{array}{rrrr}
+ 1 & 1 & 1 & 1 \\
+ 1 & 1 & -\zeta_{3} - 1 & \zeta_{3} \\
+ 1 & 1 & \zeta_{3} & -\zeta_{3} - 1 \\
+ 3 & -1 & 0 & 0
+ \end{array}\right)
+
+O Sage também inclui grupos clássicos matriciais sobre corpos finitos:
+
+::
+
+ sage: MS = MatrixSpace(GF(7), 2)
+ sage: gens = [MS([[1,0],[-1,1]]),MS([[1,1],[0,1]])]
+ sage: G = MatrixGroup(gens)
+ sage: G.conjugacy_class_representatives()
+ [
+ [1 0]
+ [0 1],
+ [0 1]
+ [6 1],
+ ...
+ [6 0]
+ [0 6]
+ ]
+ sage: G = Sp(4,GF(7))
+ sage: G._gap_init_()
+ 'Sp(4, 7)'
+ sage: G
+ Symplectic Group of rank 2 over Finite Field of size 7
+ sage: G.random_element() # random output
+ [5 5 5 1]
+ [0 2 6 3]
+ [5 0 1 0]
+ [4 6 3 4]
+ sage: G.order()
+ 276595200
+
+Você também pode fazer cálculos usando grupos abelianos (finitos ou
+infinitos):
+
+::
+
+ sage: F = AbelianGroup(5, [5,5,7,8,9], names='abcde')
+ sage: (a, b, c, d, e) = F.gens()
+ sage: d * b**2 * c**3
+ b^2*c^3*d
+ sage: F = AbelianGroup(3,[2]*3); F
+ Multiplicative Abelian Group isomorphic to C2 x C2 x C2
+ sage: H = AbelianGroup([2,3], names="xy"); H
+ Multiplicative Abelian Group isomorphic to C2 x C3
+ sage: AbelianGroup(5)
+ Multiplicative Abelian Group isomorphic to Z x Z x Z x Z x Z
+ sage: AbelianGroup(5).order()
+ +Infinity
diff --git a/doc/pt/tutorial/tour_help.rst b/doc/pt/tutorial/tour_help.rst
new file mode 100644
--- /dev/null
+++ b/doc/pt/tutorial/tour_help.rst
@@ -0,0 +1,363 @@
+.. _chapter-help:
+
+Obtendo ajuda
+=============
+
+O Sage possui vasta documentação, acessível digitando o nome de uma
+função ou constante (por exemplo), seguido pelo ponto de interrogação:
+
+.. skip
+
+::
+
+ sage: tan?
+ Type: <class 'sage.calculus.calculus.Function_tan'>
+ Definition: tan( [noargspec] )
+ Docstring:
+
+ The tangent function
+
+ EXAMPLES:
+ sage: tan(pi)
+ 0
+ sage: tan(3.1415)
+ -0.0000926535900581913
+ sage: tan(3.1415/4)
+ 0.999953674278156
+ sage: tan(pi/4)
+ 1
+ sage: tan(1/2)
+ tan(1/2)
+ sage: RR(tan(1/2))
+ 0.546302489843790
+ sage: log2?
+ Type: <class 'sage.functions.constants.Log2'>
+ Definition: log2( [noargspec] )
+ Docstring:
+
+ The natural logarithm of the real number 2.
+
+ EXAMPLES:
+ sage: log2
+ log2
+ sage: float(log2)
+ 0.69314718055994529
+ sage: RR(log2)
+ 0.693147180559945
+ sage: R = RealField(200); R
+ Real Field with 200 bits of precision
+ sage: R(log2)
+ 0.69314718055994530941723212145817656807550013436025525412068
+ sage: l = (1-log2)/(1+log2); l
+ (1 - log(2))/(log(2) + 1)
+ sage: R(l)
+ 0.18123221829928249948761381864650311423330609774776013488056
+ sage: maxima(log2)
+ log(2)
+ sage: maxima(log2).float()
+ .6931471805599453
+ sage: gp(log2)
+ 0.6931471805599453094172321215 # 32-bit
+ 0.69314718055994530941723212145817656807 # 64-bit
+ sage: sudoku?
+ File: sage/local/lib/python2.5/site-packages/sage/games/sudoku.py
+ Type: <type 'function'>
+ Definition: sudoku(A)
+ Docstring:
+
+ Solve the 9x9 Sudoku puzzle defined by the matrix A.
+
+ EXAMPLE:
+ sage: A = matrix(ZZ,9,[5,0,0, 0,8,0, 0,4,9, 0,0,0, 5,0,0,
+ 0,3,0, 0,6,7, 3,0,0, 0,0,1, 1,5,0, 0,0,0, 0,0,0, 0,0,0, 2,0,8, 0,0,0,
+ 0,0,0, 0,0,0, 0,1,8, 7,0,0, 0,0,4, 1,5,0, 0,3,0, 0,0,2,
+ 0,0,0, 4,9,0, 0,5,0, 0,0,3])
+ sage: A
+ [5 0 0 0 8 0 0 4 9]
+ [0 0 0 5 0 0 0 3 0]
+ [0 6 7 3 0 0 0 0 1]
+ [1 5 0 0 0 0 0 0 0]
+ [0 0 0 2 0 8 0 0 0]
+ [0 0 0 0 0 0 0 1 8]
+ [7 0 0 0 0 4 1 5 0]
+ [0 3 0 0 0 2 0 0 0]
+ [4 9 0 0 5 0 0 0 3]
+ sage: sudoku(A)
+ [5 1 3 6 8 7 2 4 9]
+ [8 4 9 5 2 1 6 3 7]
+ [2 6 7 3 4 9 5 8 1]
+ [1 5 8 4 6 3 9 7 2]
+ [9 7 4 2 1 8 3 6 5]
+ [3 2 6 7 9 5 4 1 8]
+ [7 8 2 9 3 4 1 5 6]
+ [6 3 5 1 7 2 8 9 4]
+ [4 9 1 8 5 6 7 2 3]
+
+O Sage também fornece completamento tab: digite as primeiras letras de
+uma função e então pressione a tecla tab. Por exemplo, se você digitar
+``ta`` seguido de ``TAB``, o Sage vai imprimir ``tachyon, tan, tanh,
+taylor``. Essa é uma boa forma de encontrar nomes de funções e outras
+estruturas no Sage.
+
+
+.. _section-functions:
+
+Funções, Tabulação, e Contagem
+===============================
+
+Para definir uma nova função no Sage, use o comando ``def`` e dois
+pontos após a lista de nomes das variáveis. Por exemplo:
+
+::
+
+ sage: def is_even(n):
+ ... return n%2 == 0
+ ...
+ sage: is_even(2)
+ True
+ sage: is_even(3)
+ False
+
+Observação: Dependendo da versão do tutorial que você está lendo,
+você pode ver três pontos ``...`` na segunda linha desse exemplo. Não
+digite esses pontos; eles são apenas para enfatizar que o código está
+tabulado. Se for esse o caso, pressione [Enter] uma vez após o fim do
+bloco de código para inserir uma linha em branco e concluir a
+definição da função.
+
+Você não especifica o tipo de dado de nenhum dos argumentos da função.
+É possível especificar argumentos múltiplos, cada um dos quais pode
+ter um valor opcional padrão. Por exemplo, a função abaixo usa o valor
+padrão ``divisor=2`` se ``divisor`` não é especificado.
+
+::
+
+ sage: def is_divisible_by(number, divisor=2):
+ ... return number%divisor == 0
+ sage: is_divisible_by(6,2)
+ True
+ sage: is_divisible_by(6)
+ True
+ sage: is_divisible_by(6, 5)
+ False
+
+Você também pode especificar explicitamente um ou mais argumentos
+quando evocar uma função; se você especificar os argumentos
+explicitamente, você pode fazê-lo em qualquer ordem:
+
+.. link
+
+::
+
+ sage: is_divisible_by(6, divisor=5)
+ False
+ sage: is_divisible_by(divisor=2, number=6)
+ True
+
+Em Python, blocos de código não são indicados por colchetes ou blocos
+de início e fim, como em outras linguagens. Em vez disso, blocos de
+código são indicados por tabulação, que devem estar alinhadas
+exatamente. Por exemplo, o seguinte código possui um erro de sintaxe
+porque o comando ``return`` não possui a mesma tabulação da linha que
+inicia o seu bloco de código.
+
+.. skip
+
+::
+
+ sage: def even(n):
+ ... v = []
+ ... for i in range(3,n):
+ ... if i % 2 == 0:
+ ... v.append(i)
+ ... return v
+ Syntax Error:
+ return v
+
+Se você corrigir a tabulação, a função fica correta:
+
+::
+
+ sage: def even(n):
+ ... v = []
+ ... for i in range(3,n):
+ ... if i % 2 == 0:
+ ... v.append(i)
+ ... return v
+ sage: even(10)
+ [4, 6, 8]
+
+Não é necessário inserir ponto-e-vírgula no final da linha. Todavia,
+você pode inserir múltiplos comandos em uma mesma linha separados por
+ponto-e-vírgula:
+
+::
+
+ sage: a = 5; b = a + 3; c = b^2; c
+ 64
+
+Se você quiser que uma única linha de comando seja escrita em mais de
+uma linha, use a barra invertida para quebrar a linha:
+
+::
+
+ sage: 2 + \
+ ... 3
+ 5
+
+Em Sage, a contagem é feita iterando sobre um intervalo de inteiros.
+Por exemplo, a primeira linha abaixo é equivalente a ``for(i=0; i<3;
+i++)`` em C++ ou Java:
+
+::
+
+ sage: for i in range(3):
+ ... print i
+ 0
+ 1
+ 2
+
+A primeira linha abaixo é equivalente a ``for(i=2; i<5; i++)``.
+
+::
+
+ sage: for i in range(2,5):
+ ... print i
+ 2
+ 3
+ 4
+
+O Terceiro argumento controla o passo. O comando abaixo é equivalente
+a ``for(i=1; i<6; i+=2)``.
+
+::
+
+ sage: for i in range(1,6,2):
+ ... print i
+ 1
+ 3
+ 5
+
+Frequentemente deseja-se criar uma tabela para visualizar resultados
+calculados com o Sage. Uma forma fácil de fazer isso é utilizando
+formatação de strings. Abaixo, criamos três colunas cada uma com
+largura exatamente 6, e fazemos uma tabela com quadrados e cubos de
+alguns números.
+
+::
+
+ sage: for i in range(5):
+ ... print '%6s %6s %6s'%(i, i^2, i^3)
+ 0 0 0
+ 1 1 1
+ 2 4 8
+ 3 9 27
+ 4 16 64
+
+A estrutura de dados mais básica em Sage é a lista, que é -- como o
+nome sugere -- simplesmente uma lista de objetos arbitrários. Por
+exemplo, o comando ``range`` que usamos acima cria uma lista:
+
+::
+
+ sage: range(2,10)
+ [2, 3, 4, 5, 6, 7, 8, 9]
+
+Abaixo segue uma lista mais complicada:
+
+::
+
+ sage: v = [1, "hello", 2/3, sin(x^3)]
+ sage: v
+ [1, 'hello', 2/3, sin(x^3)]
+
+Listas são indexadas começando do 0, como em várias linguagens de
+programação.
+
+.. link
+
+::
+
+ sage: v[0]
+ 1
+ sage: v[3]
+ sin(x^3)
+
+Use ``len(v)`` para obter o comprimento de ``v``, use
+``v.append(obj)`` para inserir um novo objeto no final de ``v``, e use
+``del v[i]`` para remover o :math:`i`-ésimo elemento de ``v``:
+
+.. link
+
+::
+
+ sage: len(v)
+ 4
+ sage: v.append(1.5)
+ sage: v
+ [1, 'hello', 2/3, sin(x^3), 1.50000000000000]
+ sage: del v[1]
+ sage: v
+ [1, 2/3, sin(x^3), 1.50000000000000]
+
+Outra importante estrutura de dados é o dicionário (ou lista
+associativa). Ele funciona como uma lista, exceto que pode ser
+indexado por vários tipos de objeto (os índices devem ser imutáveis):
+
+::
+
+ sage: d = {'hi':-2, 3/8:pi, e:pi}
+ sage: d['hi']
+ -2
+ sage: d[e]
+ pi
+
+Você pode também definir novos tipos de dados usando classes.
+Encapsular objetos matemáticos usando classes é uma técnica poderosa
+que pode ajudar a simplificar e organizar os seus programas em Sage.
+Abaixo, definimos uma nova classe que representa a lista de inteiros
+pares positivos até *n*; essa classe é derivada do tipo ``list``.
+
+::
+
+ sage: class Evens(list):
+ ... def __init__(self, n):
+ ... self.n = n
+ ... list.__init__(self, range(2, n+1, 2))
+ ... def __repr__(self):
+ ... return "Even positive numbers up to n."
+
+O método ``__init__`` é evocado para inicializar o objeto quando ele é
+criado; o método ``__repr__`` imprime o objeto. Nós evocamos o
+construtor ``__init__`` do tipo ``list`` na segunda linha do método
+``__init__``. Criamos um objeto da classe ``Evens`` da seguinte forma:
+
+.. link
+
+::
+
+ sage: e = Evens(10)
+ sage: e
+ Even positive numbers up to n.
+
+Note que ``e`` imprime usando o método ``__repr__`` que nós
+definimos. Para ver a lista de números, use a função ``list``:
+
+.. link
+
+::
+
+ sage: list(e)
+ [2, 4, 6, 8, 10]
+
+Podemos também acessar o atributo ``n`` ou tratar ``e`` como uma
+lista.
+
+.. link
+
+::
+
+ sage: e.n
+ 10
+ sage: e[2]
+ 6
diff --git a/doc/pt/tutorial/tour_linalg.rst b/doc/pt/tutorial/tour_linalg.rst
new file mode 100644
--- /dev/null
+++ b/doc/pt/tutorial/tour_linalg.rst
@@ -0,0 +1,233 @@
+.. _section-linalg:
+
+Álgebra Linear
+==============
+
+O Sage fornece os objetos usuais em álgebra linear, por exemplo, o
+polinômio característico, matriz escalonada, traço, decomposição,
+etc., de uma matriz.
+
+Criar e multiplicar matrizes é fácil e natural:
+
+::
+
+ sage: A = Matrix([[1,2,3],[3,2,1],[1,1,1]])
+ sage: w = vector([1,1,-4])
+ sage: w*A
+ (0, 0, 0)
+ sage: A*w
+ (-9, 1, -2)
+ sage: kernel(A)
+ Free module of degree 3 and rank 1 over Integer Ring
+ Echelon basis matrix:
+ [ 1 1 -4]
+
+Note que no Sage, o núcleo de uma matriz :math:`A` é o núcleo à
+esquerda, i.e., o conjunto de vetores :math:`w` tal que :math:`wA=0`.
+
+Resolver equações matriciais é fácil usando o método ``solve_right``.
+Calculando ``A.solve_right(Y)`` obtém-se uma matrix (ou vetor)
+:math:`X` tal que :math:`AX=Y`:
+
+.. link
+
+::
+
+ sage: Y = vector([0, -4, -1])
+ sage: X = A.solve_right(Y)
+ sage: X
+ (-2, 1, 0)
+ sage: A * X # checking our answer...
+ (0, -4, -1)
+
+Uma barra invertida ``\`` pode ser usada no lugar de ``solve_right``;
+use ``A \ Y`` no lugar de ``A.solve_right(Y)``.
+
+.. link
+
+::
+
+ sage: A \ Y
+ (-2, 1, 0)
+
+Se não existir solução, o Sage retorna um erro:
+
+.. skip
+
+::
+
+ sage: A.solve_right(w)
+ Traceback (most recent call last):
+ ...
+ ValueError: matrix equation has no solutions
+
+Similarmente, use ``A.solve_left(Y)`` para resolver para :math:`X` em
+:math:`XA=Y`.
+
+O Sage também pode calcular autovalores e autovetores::
+
+ sage: A = matrix([[0, 4], [-1, 0]])
+ sage: A.eigenvalues ()
+ [-2*I, 2*I]
+ sage: B = matrix([[1, 3], [3, 1]])
+ sage: B.eigenvectors_left()
+ [(4, [
+ (1, 1)
+ ], 1), (-2, [
+ (1, -1)
+ ], 1)]
+
+(A sintaxe para a resposta de ``eigenvectors_left`` é uma lista com
+três componentes: (autovalor, autovetor, multiplicidade).) Autovalores
+e autovetores sobre ``QQ`` ou ``RR`` também podem ser calculados
+usando o Maxima (veja :ref:`section-maxima`).
+
+Como observado em :ref:`section-rings`, o anel sobre o qual a matriz
+esta definida afeta alguma de suas propriedades. A seguir, o primeiro
+argumento do comando ``matrix`` diz para o Sage considerar a matriz
+como uma matriz de inteiros (o caso ``ZZ``), uma matriz de números
+racionais (``QQ``), ou uma matriz de números reais (``RR``)::
+
+ sage: AZ = matrix(ZZ, [[2,0], [0,1]])
+ sage: AQ = matrix(QQ, [[2,0], [0,1]])
+ sage: AR = matrix(RR, [[2,0], [0,1]])
+ sage: AZ.echelon_form()
+ [2 0]
+ [0 1]
+ sage: AQ.echelon_form()
+ [1 0]
+ [0 1]
+ sage: AR.echelon_form()
+ [ 1.00000000000000 0.000000000000000]
+ [0.000000000000000 1.00000000000000]
+
+Espaços de Matrizes
+-------------------
+
+Agora criamos o espaço :math:`\text{Mat}_{3\times 3}(\QQ)` de matrizes
+`3 \times 3` com entradas racionais::
+
+ sage: M = MatrixSpace(QQ,3)
+ sage: M
+ Full MatrixSpace of 3 by 3 dense matrices over Rational Field
+
+(Para especificar o espaço de matrizes 3 por 4, você usaria
+``MatrixSpace(QQ,3,4)``. Se o número de colunas é omitido, ele é
+considerado como igual ao número de linhas, portanto,
+``MatrixSpace(QQ,3)`` é sinônimo de ``MatrixSpace(QQ,3,3)``.) O espaço
+de matrizes possui uma base que o Sage armazena como uma lista:
+
+.. link
+
+::
+
+ sage: B = M.basis()
+ sage: len(B)
+ 9
+ sage: B[1]
+ [0 1 0]
+ [0 0 0]
+ [0 0 0]
+
+Vamos criar uma matriz como um elemento de ``M``.
+
+.. link
+
+::
+
+ sage: A = M(range(9)); A
+ [0 1 2]
+ [3 4 5]
+ [6 7 8]
+
+A seguir calculamos a sua forma escalonada e o núcleo.
+
+.. link
+
+::
+
+ sage: A.echelon_form()
+ [ 1 0 -1]
+ [ 0 1 2]
+ [ 0 0 0]
+ sage: A.kernel()
+ Vector space of degree 3 and dimension 1 over Rational Field
+ Basis matrix:
+ [ 1 -2 1]
+
+Agora ilustramos o cálculo com matrizes definidas sobre um corpo
+finito:
+
+::
+
+ sage: M = MatrixSpace(GF(2),4,8)
+ sage: A = M([1,1,0,0, 1,1,1,1, 0,1,0,0, 1,0,1,1,
+ ... 0,0,1,0, 1,1,0,1, 0,0,1,1, 1,1,1,0])
+ sage: A
+ [1 1 0 0 1 1 1 1]
+ [0 1 0 0 1 0 1 1]
+ [0 0 1 0 1 1 0 1]
+ [0 0 1 1 1 1 1 0]
+ sage: rows = A.rows()
+ sage: A.columns()
+ [(1, 0, 0, 0), (1, 1, 0, 0), (0, 0, 1, 1), (0, 0, 0, 1),
+ (1, 1, 1, 1), (1, 0, 1, 1), (1, 1, 0, 1), (1, 1, 1, 0)]
+ sage: rows
+ [(1, 1, 0, 0, 1, 1, 1, 1), (0, 1, 0, 0, 1, 0, 1, 1),
+ (0, 0, 1, 0, 1, 1, 0, 1), (0, 0, 1, 1, 1, 1, 1, 0)]
+
+Criamos o subespaço sobre `\GF{2}` gerado pelas linhas acima.
+
+.. link
+
+::
+
+ sage: V = VectorSpace(GF(2),8)
+ sage: S = V.subspace(rows)
+ sage: S
+ Vector space of degree 8 and dimension 4 over Finite Field of size 2
+ Basis matrix:
+ [1 0 0 0 0 1 0 0]
+ [0 1 0 0 1 0 1 1]
+ [0 0 1 0 1 1 0 1]
+ [0 0 0 1 0 0 1 1]
+ sage: A.echelon_form()
+ [1 0 0 0 0 1 0 0]
+ [0 1 0 0 1 0 1 1]
+ [0 0 1 0 1 1 0 1]
+ [0 0 0 1 0 0 1 1]
+
+A base de `S` usada pelo Sage é obtida a partir das linhas não-nulas
+da forma escalonada da matriz de geradores de `S`.
+
+Álgebra Linear Esparsa
+----------------------
+
+O Sage fornece suporte para álgebra linear esparsa.
+
+::
+
+ sage: M = MatrixSpace(QQ, 100, sparse=True)
+ sage: A = M.random_element(density = 0.05)
+ sage: E = A.echelon_form()
+
+O algoritmo multi-modular no Sage é bom para matrizes quadradas (mas
+não muito bom para matrizes que não são quadradas):
+
+::
+
+ sage: M = MatrixSpace(QQ, 50, 100, sparse=True)
+ sage: A = M.random_element(density = 0.05)
+ sage: E = A.echelon_form()
+ sage: M = MatrixSpace(GF(2), 20, 40, sparse=True)
+ sage: A = M.random_element()
+ sage: E = A.echelon_form()
+
+Note que o Python é sensível a maiúsculas e minúsculas:
+
+::
+
+ sage: M = MatrixSpace(QQ, 10,10, Sparse=True)
+ Traceback (most recent call last):
+ ...
+ TypeError: MatrixSpace() got an unexpected keyword argument 'Sparse'
diff --git a/doc/pt/tutorial/tour_numtheory.rst b/doc/pt/tutorial/tour_numtheory.rst
new file mode 100644
--- /dev/null
+++ b/doc/pt/tutorial/tour_numtheory.rst
@@ -0,0 +1,168 @@
+Teoria de Números
+=================
+
+O Sage possui extensa funcionalidade para teoria de números. Por
+exemplo, podemos fazer aritmética em :math:`\ZZ/N\ZZ` da seguinte
+forma:
+
+::
+
+ sage: R = IntegerModRing(97)
+ sage: a = R(2) / R(3)
+ sage: a
+ 33
+ sage: a.rational_reconstruction()
+ 2/3
+ sage: b = R(47)
+ sage: b^20052005
+ 50
+ sage: b.modulus()
+ 97
+ sage: b.is_square()
+ True
+
+O Sage contém funções comuns em teoria de números. Por exemplo,
+
+::
+
+ sage: gcd(515,2005)
+ 5
+ sage: factor(2005)
+ 5 * 401
+ sage: c = factorial(25); c
+ 15511210043330985984000000
+ sage: [valuation(c,p) for p in prime_range(2,23)]
+ [22, 10, 6, 3, 2, 1, 1, 1]
+ sage: next_prime(2005)
+ 2011
+ sage: previous_prime(2005)
+ 2003
+ sage: divisors(28); sum(divisors(28)); 2*28
+ [1, 2, 4, 7, 14, 28]
+ 56
+ 56
+
+Perfeito!
+
+A função ``sigma(n,k)`` do Sage soma as :math:`k`-ésimas potências dos
+divisores de ``n``:
+
+::
+
+ sage: sigma(28,0); sigma(28,1); sigma(28,2)
+ 6
+ 56
+ 1050
+
+A seguir ilustramos o algoritmo de Euclides estendido, a função
+:math:`\phi` de Euler, e o teorema do resto Chinês:
+
+::
+
+ sage: d,u,v = xgcd(12,15)
+ sage: d == u*12 + v*15
+ True
+ sage: n = 2005
+ sage: inverse_mod(3,n)
+ 1337
+ sage: 3 * 1337
+ 4011
+ sage: prime_divisors(n)
+ [5, 401]
+ sage: phi = n*prod([1 - 1/p for p in prime_divisors(n)]); phi
+ 1600
+ sage: euler_phi(n)
+ 1600
+ sage: prime_to_m_part(n, 5)
+ 401
+
+Agora verificamos algo sobre o problema :math:`3n+1`.
+
+::
+
+ sage: n = 2005
+ sage: for i in range(1000):
+ ... n = 3*odd_part(n) + 1
+ ... if odd_part(n)==1:
+ ... print i
+ ... break
+ 38
+
+Por fim, ilustramos o teorema do resto Chinês.
+
+::
+
+ sage: x = crt(2, 1, 3, 5); x
+ 11
+ sage: x % 3 # x mod 3 = 2
+ 2
+ sage: x % 5 # x mod 5 = 1
+ 1
+ sage: [binomial(13,m) for m in range(14)]
+ [1, 13, 78, 286, 715, 1287, 1716, 1716, 1287, 715, 286, 78, 13, 1]
+ sage: [binomial(13,m)%2 for m in range(14)]
+ [1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1]
+ sage: [kronecker(m,13) for m in range(1,13)]
+ [1, -1, 1, 1, -1, -1, -1, -1, 1, 1, -1, 1]
+ sage: n = 10000; sum([moebius(m) for m in range(1,n)])
+ -23
+ sage: list(partitions(4))
+ [(1, 1, 1, 1), (1, 1, 2), (2, 2), (1, 3), (4,)]
+
+Números :math:`p`-ádicos
+------------------------
+
+O corpo dos números :math:`p`-ádicos está implementado em Sage. Note
+que uma vez que um corpo :math:`p`-ádico é criado, você não pode
+alterar a sua precisão.
+
+::
+
+ sage: K = Qp(11); K
+ 11-adic Field with capped relative precision 20
+ sage: a = K(211/17); a
+ 4 + 4*11 + 11^2 + 7*11^3 + 9*11^5 + 5*11^6 + 4*11^7 + 8*11^8 + 7*11^9
+ + 9*11^10 + 3*11^11 + 10*11^12 + 11^13 + 5*11^14 + 6*11^15 + 2*11^16
+ + 3*11^17 + 11^18 + 7*11^19 + O(11^20)
+ sage: b = K(3211/11^2); b
+ 10*11^-2 + 5*11^-1 + 4 + 2*11 + O(11^18)
+
+Muito trabalho foi feito implementando anéis de inteiros em corpos
+:math:`p`-ádicos ou corpos numéricos além de `Z`. O leitor
+interessado é convidado a perguntar mais detalhes aos especialistas na
+lista ``sage-support`` no Google Groups.
+
+Diversos métodos relacionados já estão implementados na classe
+NumberField.
+
+::
+
+ sage: R.<x> = PolynomialRing(QQ)
+ sage: K = NumberField(x^3 + x^2 - 2*x + 8, 'a')
+ sage: K.integral_basis()
+ [1, 1/2*a^2 + 1/2*a, a^2]
+
+.. link
+
+::
+
+ sage: K.galois_group(type="pari")
+ Galois group PARI group [6, -1, 2, "S3"] of degree 3 of the Number Field
+ in a with defining polynomial x^3 + x^2 - 2*x + 8
+
+.. link
+
+::
+
+ sage: K.polynomial_quotient_ring()
+ Univariate Quotient Polynomial Ring in a over Rational Field with modulus
+ x^3 + x^2 - 2*x + 8
+ sage: K.units()
+ [3*a^2 + 13*a + 13]
+ sage: K.discriminant()
+ -503
+ sage: K.class_group()
+ Class group of order 1 of Number Field in a with
+ defining polynomial x^3 + x^2 - 2*x + 8
+ sage: K.class_number()
+ 1
diff --git a/doc/pt/tutorial/tour_plotting.rst b/doc/pt/tutorial/tour_plotting.rst
new file mode 100644
--- /dev/null
+++ b/doc/pt/tutorial/tour_plotting.rst
@@ -0,0 +1,231 @@
+.. _section-plot:
+
+Gráficos
+========
+
+O Sage pode produzir gráficos bidimensionais e tridimensionais.
+
+Gráficos Bidimensionais
+-----------------------
+
+Em duas dimensões, o Sage pode desenhar círculos, linhas, e polígonos;
+gráficos de funções em coordenadas retangulares, e também coordenadas
+polares; gráficos de contorno e gráficos de campos vetoriais.
+Apresentamos alguns exemplos desses gráficos aqui. Para mais exemplos
+de gráficos com o Sage, veja :ref:`section-systems` e
+:ref:`section-maxima`, e também a documentação `Sage Constructions
+<http://www.sagemath.org/doc/constructions/>`_.
+
+Este comando produz um círculo amarelo de raio 1, centrado na origem.
+
+::
+
+ sage: circle((0,0), 1, rgbcolor=(1,1,0))
+
+Você pode também produzir um círculo preenchido:
+
+::
+
+ sage: circle((0,0), 1, rgbcolor=(1,1,0), fill=True)
+
+Outra possibilidade é criar um círculo atribuindo-o a uma variável;
+isso não cria um gráfico:
+
+::
+
+ sage: c = circle((0,0), 1, rgbcolor=(1,1,0))
+
+Para criar o gráfico, use ``c.show()`` ou ``show(c)``, da seguinte
+forma:
+
+.. link
+
+::
+
+ sage: c.show()
+
+Alternativamente, o comando ``c.save('filename.png')`` salva o gráfico
+no arquivo citado.
+
+Agora, esses 'círculos' parecem mais elipses porque os eixos estão em
+escalas diferentes. Você pode alterar isso:
+
+.. link
+
+::
+
+ sage: c.show(aspect_ratio=1)
+
+O comando ``show(c, aspect_ratio=1)`` produz o mesmo resultado, ou
+você pode salvar a figura usando ``c.save('filename.png',
+aspect_ratio=1)``.
+
+É fácil criar o gráfico de funções simples:
+
+::
+
+ sage: plot(cos, (-5,5))
+
+Após especificar uma variável, você também pode criar gráficos
+paramétricos:
+
+::
+
+ sage: x = var('x')
+ sage: parametric_plot((cos(x),sin(x)^3),(x,0,2*pi),rgbcolor=hue(0.6))
+
+É importante notar que os eixos dos gráficos vão se intersectar apenas
+se a origem estiver no escopo do gráfico, e que valores grandes podem
+ser representados usando notação científica.
+
+::
+
+ sage: plot(x^2,(x,300,500))
+
+Você pode combinar vários gráficos somando-os:
+
+::
+
+ sage: x = var('x')
+ sage: p1 = parametric_plot((cos(x),sin(x)),(x,0,2*pi),rgbcolor=hue(0.2))
+ sage: p2 = parametric_plot((cos(x),sin(x)^2),(x,0,2*pi),rgbcolor=hue(0.4))
+ sage: p3 = parametric_plot((cos(x),sin(x)^3),(x,0,2*pi),rgbcolor=hue(0.6))
+ sage: show(p1+p2+p3, axes=false)
+
+Uma boa forma de produzir figuras preenchidas é criar uma lista de
+pontos (``L`` no exemplo abaixo) e então usar o comando ``polygon``
+para fazer o gráfico do polígono formado por esses pontos. Por
+exemplo, aqui está um "deltoid" verde:
+
+::
+
+ sage: L = [[-1+cos(pi*i/100)*(1+cos(pi*i/100)),\
+ ... 2*sin(pi*i/100)*(1-cos(pi*i/100))] for i in range(200)]
+ sage: p = polygon(L, rgbcolor=(1/8,3/4,1/2))
+ sage: p
+
+Digite ``show(p, axes=false)`` para visualizar isso sem os eixos.
+
+Você pode adicionar texto ao gráfico:
+
+::
+
+ sage: L = [[6*cos(pi*i/100)+5*cos((6/2)*pi*i/100),\
+ ... 6*sin(pi*i/100)-5*sin((6/2)*pi*i/100)] for i in range(200)]
+ sage: p = polygon(L, rgbcolor=(1/8,1/4,1/2))
+ sage: t = text("hypotrochoid", (5,4), rgbcolor=(1,0,0))
+ sage: show(p+t)
+
+Professores de cálculo frequentemente desenham o seguinte gráfico na
+lousa: não apenas um ramo do arco-seno, mas vários deles: isto é, o
+gráfico de :math:`y=\sin(x)` para :math:`x` entre :math:`-2\pi` e
+:math:`2\pi`, refletido com respeito a reta :math:`x=y`. Os seguintes
+comandos fazem isso:
+
+::
+
+ sage: v = [(sin(x),x) for x in srange(-2*float(pi),2*float(pi),0.1)]
+ sage: line(v)
+
+Como a função tangente possui imagem maior do que o seno, se você usar
+o mesmo método para fazer o gráfico da função inversa da função
+tangente, você deve alterar as coordenadas mínima e máxima para o eixo
+*x*:
+
+::
+
+ sage: v = [(tan(x),x) for x in srange(-2*float(pi),2*float(pi),0.01)]
+ sage: show(line(v), xmin=-20, xmax=20)
+
+O Sage também cria gráficos usando coordenadas polares, gráficos de
+contorno e gráficos de campos vetoriais (para tipos especiais de
+funções). Aqui está um exemplo de gráfico de contorno:
+
+::
+
+ sage: f = lambda x,y: cos(x*y)
+ sage: contour_plot(f, (-4, 4), (-4, 4))
+
+Gráficos Tridimensionais
+------------------------
+
+O Sage pode ser usado para criar gráficos tridimensionais. Tanto no
+Sage Notebook, como no console (linha de comando), esses gráficos serão
+exibidos usando o software de código aberto [Jmol]_, que permite girar
+e ampliar a figura usando o mouse.
+
+Use ``plot3d`` para criar o gráfico de uma função da forma `f(x, y) =
+z`:
+
+::
+
+ sage: x, y = var('x,y')
+ sage: plot3d(x^2 + y^2, (x,-2,2), (y,-2,2))
+
+Alternativamente, você pode usar ``parametric_plot3d`` para criar o
+gráfico de uma superfície onde cada coordenada `x, y, z` é determinada
+por uma função de uma ou duas variáveis (os parâmetros, tipicamente
+`u` e `v`). O gráfico anterior pode ser representado parametricamente
+na forma:
+
+::
+
+ sage: u, v = var('u, v')
+ sage: f_x(u, v) = u
+ sage: f_y(u, v) = v
+ sage: f_z(u, v) = u^2 + v^2
+ sage: parametric_plot3d([f_x, f_y, f_z], (u, -2, 2), (v, -2, 2))
+
+A terceira forma de fazer um gráfico de uma superfície no Sage é
+usando o comando ``implicit_plot3d``, que cria um gráfico de uma
+superfície definida por uma equação `f(x, y, z) = 0` (isso define um
+conjunto de pontos). Vamos fazer o gráfico de uma esfera usando a
+expressão usual:
+
+::
+
+ sage: x, y, z = var('x, y, z')
+ sage: implicit_plot3d(x^2 + y^2 + z^2 - 4, (x,-2, 2), (y,-2, 2), (z,-2, 2))
+
+Aqui estão mais alguns exemplos:
+
+`Yellow Whitney's umbrella <http://en.wikipedia.org/wiki/Whitney_umbrella>`__:
+
+::
+
+ sage: u, v = var('u,v')
+ sage: fx = u*v
+ sage: fy = u
+ sage: fz = v^2
+ sage: parametric_plot3d([fx, fy, fz], (u, -1, 1), (v, -1, 1),
+ ... frame=False, color="yellow")
+
+`Cross cap <http://en.wikipedia.org/wiki/Cross-cap>`__:
+
+::
+
+ sage: u, v = var('u,v')
+ sage: fx = (1+cos(v))*cos(u)
+ sage: fy = (1+cos(v))*sin(u)
+ sage: fz = -tanh((2/3)*(u-pi))*sin(v)
+ sage: parametric_plot3d([fx, fy, fz], (u, 0, 2*pi), (v, 0, 2*pi),
+ ... frame=False, color="red")
+
+Toro retorcido:
+
+::
+
+ sage: u, v = var('u,v')
+ sage: fx = (3+sin(v)+cos(u))*cos(2*v)
+ sage: fy = (3+sin(v)+cos(u))*sin(2*v)
+ sage: fz = sin(u)+2*cos(v)
+ sage: parametric_plot3d([fx, fy, fz], (u, 0, 2*pi), (v, 0, 2*pi),
+ ... frame=False, color="red")
+
+Lemniscata:
+
+::
+
+ sage: x, y, z = var('x,y,z')
+ sage: f(x, y, z) = 4*x^2 * (x^2 + y^2 + z^2 + z) + y^2 * (y^2 + z^2 - 1)
+ sage: implicit_plot3d(f, (x, -0.5, 0.5), (y, -1, 1), (z, -1, 1))
diff --git a/doc/pt/tutorial/tour_polynomial.rst b/doc/pt/tutorial/tour_polynomial.rst
new file mode 100644
--- /dev/null
+++ b/doc/pt/tutorial/tour_polynomial.rst
@@ -0,0 +1,332 @@
+.. _section-poly:
+
+Polinômios
+==========
+
+Nesta seção vamos ilustrar como criar e usar polinômios no Sage.
+
+
+.. _section-univariate:
+
+Polinômios em Uma Variável
+--------------------------
+
+Existem três formas de criar anéis de polinômios.
+
+::
+
+ sage: R = PolynomialRing(QQ, 't')
+ sage: R
+ Univariate Polynomial Ring in t over Rational Field
+
+Esse comando cria um anel de polinômios e diz para o Sage usar a letra
+'t' para representar a variável indeterminada quando imprimir na tela.
+Todavia, isso não define o símbolo ``t`` para uso no Sage, logo você
+não pode usá-lo para definir um polinômio (como :math:`t^2+1`)
+pertencente a ``R``.
+
+Uma forma alternativa é
+
+.. link
+
+::
+
+ sage: S = QQ['t']
+ sage: S == R
+ True
+
+As mesmas observações com respeito a ``t`` valem também nesse caso.
+
+Uma terceira e conveniente forma de definir polinômios é
+
+::
+
+ sage: R.<t> = PolynomialRing(QQ)
+
+ou
+
+::
+
+ sage: R.<t> = QQ['t']
+
+ou ainda
+
+::
+
+ sage: R.<t> = QQ[]
+
+Isso tem o efeito colateral de definir a variável ``t`` como a
+variável indeterminada do anel de polinômios, logo você pode
+facilmente construir elementos de ``R`` da seguinte forma. (Note que
+essa terceira alternativa é muito semelhante à notação usada em Magma,
+e da mesma forma que no Magma ela pode ser usada para diversos tipos
+de objetos.)
+
+.. link
+
+::
+
+ sage: poly = (t+1) * (t+2); poly
+ t^2 + 3*t + 2
+ sage: poly in R
+ True
+
+Qualquer que seja o método usado para definir um anel de polinômios,
+você pode recuperar a variável indeterminada como o :math:`0`-ésimo
+gerador:
+
+::
+
+ sage: R = PolynomialRing(QQ, 't')
+ sage: t = R.0
+ sage: t in R
+ True
+
+Note que uma construção similar funciona com os números complexos: os
+números complexos podem ser vistos como sendo gerados pelo símbolo
+``i`` sobre os números reais; logo temos o seguinte:
+
+::
+
+ sage: CC
+ Complex Field with 53 bits of precision
+ sage: CC.0 # 0th generator of CC
+ 1.00000000000000*I
+
+Para anel de polinômios, você pode obter tanto o anel como o seu
+gerador, ou somente o gerador, no momento em que o anel for criado, da
+seguinte forma:
+
+::
+
+ sage: R, t = QQ['t'].objgen()
+ sage: t = QQ['t'].gen()
+ sage: R, t = objgen(QQ['t'])
+ sage: t = gen(QQ['t'])
+
+Finalmente apresentamos um pouco de aritmética em :math:`\QQ[t]`.
+
+::
+
+ sage: R, t = QQ['t'].objgen()
+ sage: f = 2*t^7 + 3*t^2 - 15/19
+ sage: f^2
+ 4*t^14 + 12*t^9 - 60/19*t^7 + 9*t^4 - 90/19*t^2 + 225/361
+ sage: cyclo = R.cyclotomic_polynomial(7); cyclo
+ t^6 + t^5 + t^4 + t^3 + t^2 + t + 1
+ sage: g = 7 * cyclo * t^5 * (t^5 + 10*t + 2)
+ sage: g
+ 7*t^16 + 7*t^15 + 7*t^14 + 7*t^13 + 77*t^12 + 91*t^11 + 91*t^10 + 84*t^9
+ + 84*t^8 + 84*t^7 + 84*t^6 + 14*t^5
+ sage: F = factor(g); F
+ (7) * t^5 * (t^5 + 10*t + 2) * (t^6 + t^5 + t^4 + t^3 + t^2 + t + 1)
+ sage: F.unit()
+ 7
+ sage: list(F)
+ [(t, 5), (t^5 + 10*t + 2, 1), (t^6 + t^5 + t^4 + t^3 + t^2 + t + 1, 1)]
+
+Note que a fatorização corretamente leva em conta e armazena a parte
+unitária.
+
+Se você fosse usar, por exemplo, a função ``R.cyclotomic_polynomial``
+intensamente para algum projeto de pesquisa, além de citar o Sage,
+você deveria tentar descobrir qual componente do Sage é de fato usado
+para calcular esses polinômios, e citá-lo também. Nesse caso, se você
+digitar ``R.cyclotomic_polynomial??`` para ver o código fonte, você
+irá facilmente ver uma linha ``f = pari.polcyclo(n)`` o que significa
+que o PARI é usado para o cálculo dos polinômios ciclotrômicos. Cite o
+PARI também no seu trabalho.
+
+Dividindo dois polinômios cria-se um elemento do corpo de frações (o
+qual o Sage cria automaticamente).
+
+::
+
+ sage: x = QQ['x'].0
+ sage: f = x^3 + 1; g = x^2 - 17
+ sage: h = f/g; h
+ (x^3 + 1)/(x^2 - 17)
+ sage: h.parent()
+ Fraction Field of Univariate Polynomial Ring in x over Rational Field
+
+Usando-se a série de Laurent, pode-se calcular a expansão em série no
+corpo de frações de ``QQ[x]``:
+
+::
+
+ sage: R.<x> = LaurentSeriesRing(QQ); R
+ Laurent Series Ring in x over Rational Field
+ sage: 1/(1-x) + O(x^10)
+ 1 + x + x^2 + x^3 + x^4 + x^5 + x^6 + x^7 + x^8 + x^9 + O(x^10)
+
+Se nomearmos a variável de outra forma, obtemos um anel de polinômios
+em uma variável diferente.
+
+::
+
+ sage: R.<x> = PolynomialRing(QQ)
+ sage: S.<y> = PolynomialRing(QQ)
+ sage: x == y
+ False
+ sage: R == S
+ False
+ sage: R(y)
+ x
+ sage: R(y^2 - 17)
+ x^2 - 17
+
+O anel é determinado pela variável. Note que criar um outro anel com
+variável indeterminada ``x`` não retorna um anel diferente.
+
+::
+
+ sage: R = PolynomialRing(QQ, "x")
+ sage: T = PolynomialRing(QQ, "x")
+ sage: R == T
+ True
+ sage: R is T
+ True
+ sage: R.0 == T.0
+ True
+
+O Sage também possui suporte para séries de potências e séries de
+Laurent sobre um anel arbitrário. No seguinte exemplo, nós criamos um
+elemento de :math:`\GF{7}[[T]]` e dividimos para criar um elemento de
+:math:`\GF{7}((T))`.
+
+::
+
+ sage: R.<T> = PowerSeriesRing(GF(7)); R
+ Power Series Ring in T over Finite Field of size 7
+ sage: f = T + 3*T^2 + T^3 + O(T^4)
+ sage: f^3
+ T^3 + 2*T^4 + 2*T^5 + O(T^6)
+ sage: 1/f
+ T^-1 + 4 + T + O(T^2)
+ sage: parent(1/f)
+ Laurent Series Ring in T over Finite Field of size 7
+
+Você também pode criar anéis de polinômios usando a notação de
+colchetes duplos:
+
+::
+
+ sage: GF(7)[['T']]
+ Power Series Ring in T over Finite Field of size 7
+
+Polinômios em Mais De Uma Variável
+----------------------------------
+
+Para trabalhar com polinômios em várias variáveis, nós primeiro
+declaramos o anel de polinômios e as variáveis.
+
+::
+
+ sage: R = PolynomialRing(GF(5),3,"z") # here, 3 = number of variables
+ sage: R
+ Multivariate Polynomial Ring in z0, z1, z2 over Finite Field of size 5
+
+Da mesma forma como ocorre com polinômios em uma variável, existem
+três maneiras de fazer isso:
+
+::
+
+ sage: GF(5)['z0, z1, z2']
+ Multivariate Polynomial Ring in z0, z1, z2 over Finite Field of size 5
+ sage: R.<z0,z1,z2> = GF(5)[]; R
+ Multivariate Polynomial Ring in z0, z1, z2 over Finite Field of size 5
+
+Se você quiser usar os nomes das variáveis com apenas uma letra, então
+você pode usar os seguinte comando:
+
+::
+
+ sage: PolynomialRing(GF(5), 3, 'xyz')
+ Multivariate Polynomial Ring in x, y, z over Finite Field of size 5
+
+A seguir fazemos um pouco de aritmética.
+
+::
+
+ sage: z = GF(5)['z0, z1, z2'].gens()
+ sage: z
+ (z0, z1, z2)
+ sage: (z[0]+z[1]+z[2])^2
+ z0^2 + 2*z0*z1 + z1^2 + 2*z0*z2 + 2*z1*z2 + z2^2
+
+Você também pode usar uma notação mais matemática para criar um anel
+de polinômios.
+
+::
+
+ sage: R = GF(5)['x,y,z']
+ sage: x,y,z = R.gens()
+ sage: QQ['x']
+ Univariate Polynomial Ring in x over Rational Field
+ sage: QQ['x,y'].gens()
+ (x, y)
+ sage: QQ['x'].objgens()
+ (Univariate Polynomial Ring in x over Rational Field, (x,))
+
+Polinômios em mais de uma variável são implementados no Sage usando
+dicionários em Python e a "representação distribuída" de um polinômio.
+O Sage usa o Singular [Si]_, por exemplo, para o cálculo do maior
+divisor comum e bases de Gröbner para ideais algébricos.
+
+::
+
+ sage: R, (x, y) = PolynomialRing(RationalField(), 2, 'xy').objgens()
+ sage: f = (x^3 + 2*y^2*x)^2
+ sage: g = x^2*y^2
+ sage: f.gcd(g)
+ x^2
+
+A seguir criamos o ideal :math:`(f,g)` gerado por :math:`f` e
+:math:`g`, simplesmente multiplicando ``(f,g)`` por ``R`` (nós
+poderíamos também escrever ``ideal([f,g])`` ou ``ideal(f,g)``).
+
+.. link
+
+::
+
+ sage: I = (f, g)*R; I
+ Ideal (x^6 + 4*x^4*y^2 + 4*x^2*y^4, x^2*y^2) of Multivariate Polynomial
+ Ring in x, y over Rational Field
+ sage: B = I.groebner_basis(); B
+ [x^6, x^2*y^2]
+ sage: x^2 in I
+ False
+
+A base de Gröbner acima não é uma lista mas sim uma sequência
+imutável. Isso implica que ela possui universo (universe) e parente
+(parent), e não pode ser modificada (o que é bom pois ocasionaria
+erros em outras rotinas que usam bases de Gröbner).
+
+.. link
+
+::
+
+ sage: B.parent()
+ Category of sequences in Multivariate Polynomial Ring in x, y over Rational
+ Field
+ sage: B.universe()
+ Multivariate Polynomial Ring in x, y over Rational Field
+ sage: B[1] = x
+ Traceback (most recent call last):
+ ...
+ ValueError: object is immutable; please change a copy instead.
+
+Um pouco (não tanto quanto gostaríamos) de álgebra comutativa está
+disponível no Sage, implementado via Singular. Por exemplo, podemos
+calcular a decomposição primaria e primos associados de :math:`I`:
+
+.. link
+
+::
+
+ sage: I.primary_decomposition()
+ [Ideal (x^2) of Multivariate Polynomial Ring in x, y over Rational Field,
+ Ideal (y^2, x^6) of Multivariate Polynomial Ring in x, y over Rational Field]
+ sage: I.associated_primes()
+ [Ideal (x) of Multivariate Polynomial Ring in x, y over Rational Field,
+ Ideal (y, x) of Multivariate Polynomial Ring in x, y over Rational Field]
diff --git a/doc/pt/tutorial/tour_rings.rst b/doc/pt/tutorial/tour_rings.rst
new file mode 100644
--- /dev/null
+++ b/doc/pt/tutorial/tour_rings.rst
@@ -0,0 +1,148 @@
+.. _section-rings:
+
+Anéis Básicos
+=============
+
+Quando se define matrizes, vetores, ou polinômios, é as vezes útil, e
+as vezes necessário, especificar o "anel" sobre o qual o objeto será
+definido. Um *anel* é uma estrutura matemática na qual se tem noções
+de adição e multiplicação bem definidas; se você nunca ouviu falar
+sobre anéis, você provavelmente só precisa saber a respeito dos
+seguintes exemplos:
+
+* os inteiros `\{..., -1, 0, 1, 2,... \}`, que são chamados ``ZZ`` no
+ Sage.
+* os números racionais -- i. e., frações, ou razões, de inteiros --
+ que são chamados ``QQ`` no Sage.
+* os números reais, chamados de ``RR`` no Sage.
+* os números complexos, chamados de ``CC`` no Sage.
+
+Você pode precisar saber sobre essas distinções porque o mesmo
+polinômio, por exemplo, pode ser tratado diferentemente dependendo do
+anel sobre o qual está definido. A propósito, o polinômio `x^2-2`
+possui duas raízes, `\pm \sqrt{2}`. Essas raízes não são racionais,
+logo, se você esta lidando com polinômios com coeficientes racionais,
+os polinômios não serão fatorados. Com coeficientes reais, eles serão.
+Portanto você pode querer especificar o anel para garantir que você
+vai obter a informação que deseja. Os dois comandos a seguir definem
+os conjuntos de polinômios com coeficientes racionais e coeficientes
+reais, respectivamente. Os conjuntos são chamados "ratpoly" e
+"realpoly", mas esses nomes não são importantes aqui; todavia, note
+que as strings ".<t>" e ".<z>" especificam o nome das variáveis
+usadas em cada caso.
+
+::
+
+ sage: ratpoly.<t> = PolynomialRing(QQ)
+ sage: realpoly.<z> = PolynomialRing(RR)
+
+Agora ilustramos a nossa discussão sobre fatorar `x^2-2`:
+
+.. link
+
+::
+
+ sage: factor(t^2-2)
+ t^2 - 2
+ sage: factor(z^2-2)
+ (z - 1.41421356237310) * (z + 1.41421356237310)
+
+Comentários similares também se aplicam a matrizes: a forma reduzida
+de uma matriz pode depender do anel sobre o qual ela esta definida,
+como também pode os seus autovalores e autovetores. Para mais sobre
+polinômios, veja :ref:`section-poly`, para mais sobre matrizes, veja
+:ref:`section-linalg`.
+
+O símbolo ``I`` representa a raiz quadrada de :math:`-1`; ``i`` é um
+sinônimo de ``I``. Obviamente, isso não é um número racional::
+
+ sage: i # square root of -1
+ I
+ sage: i in QQ
+ False
+
+Nota: O código acima pode não funcionar como esperado se a variável
+``i`` estiver atribuída a um outro valor, por exemplo, se ela for
+usada como a variável de um laço (loop). Nesse caso, digite::
+
+ sage: reset('i')
+
+para restabelecer o valor original de ``i``.
+
+Há uma sutileza ao definir números complexos: como mencionado acima,
+o símbolo ``i`` representa a raiz quadrada de `-1`, mas é uma raiz
+quadrada de `-1` *formal* ou *simbólica*. Evocando ``CC(i)`` ou
+``CC.0`` obtém-se a raiz de `-1` complexa. Aritmética envolvendo tipos
+diferentes de números é possível graças ao que se chama de coação,
+veja :ref:`section-coercion`.
+
+::
+
+ sage: i = CC(i) # floating point complex number
+ sage: i == CC.0
+ True
+ sage: a, b = 4/3, 2/3
+ sage: z = a + b*i
+ sage: z
+ 1.33333333333333 + 0.666666666666667*I
+ sage: z.imag() # imaginary part
+ 0.666666666666667
+ sage: z.real() == a # automatic coercion before comparison
+ True
+ sage: a + b
+ 2
+ sage: 2*b == a
+ True
+ sage: parent(2/3)
+ Rational Field
+ sage: parent(4/2)
+ Rational Field
+ sage: 2/3 + 0.1 # automatic coercion before addition
+ 0.766666666666667
+ sage: 0.1 + 2/3 # coercion rules are symmetric in SAGE
+ 0.766666666666667
+
+Aqui estão mais exemplos de anéis básicos em Sage. Como observado
+acima, o anel dos números racionais pode ser referido usando ``QQ``,
+ou também ``RationalField()`` (um *corpo*, ou *field* em inglês, é um
+anel no qual a operação de multiplicação é comutativa, e todo elemento
+não-nulo possui um elemento inverso com respeito à operação de
+multiplicação. Logo, os racionais formam um corpo, mas os inteiros
+não)::
+
+ sage: RationalField()
+ Rational Field
+ sage: QQ
+ Rational Field
+ sage: 1/2 in QQ
+ True
+
+O número decimal ``1.2`` é considerado como um elemento de ``QQ``:
+número decimais que são também racionais podem ser coagidos ao conjunto de
+números racionais (veja :ref:`section-coercion`). Os números `\pi` e
+`\sqrt{2}` não são racionais, todavia::
+
+ sage: 1.2 in QQ
+ True
+ sage: pi in QQ
+ False
+ sage: pi in RR
+ True
+ sage: sqrt(2) in QQ
+ False
+ sage: sqrt(2) in CC
+ True
+
+Para uso em matemática mais avançada, o Sage também pode especificar
+outros anéis, como corpos finitos, inteiros `p`-ádicos, o anel dos
+números algébricos, anéis de polinômios, e anéis de matrizes. Aqui
+está a construção de alguns deles::
+
+ sage: GF(3)
+ Finite Field of size 3
+ sage: GF(27, 'a') # need to name the generator if not a prime field
+ Finite Field in a of size 3^3
+ sage: Zp(5)
+ 5-adic Ring with capped relative precision 20
+ sage: sqrt(3) in QQbar # algebraic closure of QQ
+ True
Reference in a new issue View git blame Copy permalink