precalculus algebra – Factoring in an induction test

I have to try the following:

$ 1 + 3 ^ 3 + … + (2n + 1) ^ 3 = (n + 1) ^ 2 (2n ^ 2 + 4n + 1) $ Inductively.

My intent:

Base case, $ n = 1 $:

$ 1 + 3 ^ 3 = (2) ^ 2 (2 cdot1 ^ 2 + 4 cdot1 + 1) $, which is true.

By inductive hypothesis, suppose $ n = k $:

$ 1 + 3 ^ 3 + … + (2k + 1) ^ 3 = (k + 1) ^ 2 (2k ^ 2 + 4k + 1) $

by $ n = k + 1 $

$ 1 + 3 ^ 3 + … + (2k + 1) ^ 3 + (2k + 3) ^ 3 = (k + 2) ^ 2 (2 (k + 1) ^ 2 + 4 (k + 1) + 1) $

Using the inductive hypothesis we need to prove that

$ (k + 1) ^ 2 (2k ^ 2 + 4k + 1) + (2k + 3) ^ 3 = (k + 2) ^ 2 (2 (k + 1) ^ 2 + 4 (k + 1) + 1) $

And here I have the problem, because I do not know how to manipulate any of the sides of the equation to prove this. I tried it on both sides but I can not find the way. One of my last attempts ended here:

$ (k + 1) ^ 2 (2k ^ 2 + 4k + 1) + (2k + 3) ^ 3 = (k + 2) ^ 2 (2 (k + 1) (k + 3) + 1) $

Which is true for alpha wolfram.

PS: I am aware that there are many documents and information about this test, but I am not looking for another form or something, because I saw many publications on how to prove this claim through induction, but all were used. the last term is (2n-1) ^ 3, and I need to prove it when it is (2n + 1) ^ 3, and the final expression is a bit different. I just need help factoring my last step.

Corrections in the inductive steps that I followed are also appreciated.

matrices – QR – Factoring: if A has full range, then R does not have zeros in the diagonal

$ Q $ It is an orthogonal matrix. $ A in mathbb {R} ^ {m times n} $ with $ m> n $ and its QR-Factorizations is $ A = QR $. Show that yes $ A $ has full range, then the diagonal elements of $ R $ They are not zero. Also show that the first $ n $ columns of $ Q $ are an orthonormal basis of the expansion of $ A $.

I tried to prove that, but without success. Can somebody help me?

Polynomials – A factoring game.

This is a toy version of a problem that I recently posted.

Imagine playing the next game. You choose a polynomial $ B $ over a finite field $ mathbb F_p $ of degree $ deg B le p-1 $ (where $ p $ He is a great cousin). I can modify your polynomial in the way you want, except that I can not add or change monomials higher than $ 0.9p $. My goal is to make the resulting polynomial completely divided into linear factors; If I do not, you win.

  • What polynomial $ B $ Will you start the game to win?
  • Is there a comprehensible classification of all the winning polynomials (for the first player)?

Factoring: How to factor two common factors into a polynomial and put them at the beginning and end respectively?

Thank you for contributing an answer to the Mathematica Stack Exchange!

  • Please make sure answer the question. Provide details and share your research!

But avoid

  • Ask for help, clarifications or respond to other answers.
  • Make statements based on opinion; Support them with references or personal experience.

Use MathJax to format equations. MathJax reference.

For more information, see our tips on how to write excellent answers.

factoring – How can I find irreducible polynomials in $ Z_ {77}[x]$

I was able to find all the polynomials reducible in $ Z_3[x]$. But $ 3 $ It is a very small number. I am interested in finding irreducible polynomials in not very small ones. $ N = pq $, where $ p, q $ they are cousins ​​I do not have to find all the irreducible polynomials. If I could have a method to get only some of them, it would be great. For example, let's say $ N = 77 $. How could I get some irreducible polynomials in $ Z_ {77}[x]$? That seems terribly intimidating.

factoring – factor no quadratic polynomial factorization

I'm using version 11.3

Expand[(Sqrt[2] - t) ^ 2]2 - 2 Sqrt[2] t + t ^ 2,

but

Factor[2-2Sqrt[2-2Sqrt[2-2Sqrt[2-2Sqrt[2] t + t ^ 2]2 - 2 Sqrt[2] t + t ^ 2. 

On the other hand, without $ sqrt {2} $ The expression is factored as expected.

Factor[1 - 2  t + t^2]
(-1 + t) ^ 2

Factoring – How to find the factors of a large number?

I have a large number x like:

n = 120;
x = FromDigits[Table[i,{i,1,n}]];

This runs quickly. But I want to find the prime factors of x, so I use this:

FactorInteger[x];

So, it takes 2s to solve it. When n grows, many more hours are needed to solve it. The "FactorInteger" function is the result. But I do not know how to improve it.

beginner – C # – Main engine (Generation, primality, factoring)

I just wrote my first C # class, so I'm looking for some comments before writing more code. The objective of the code is to provide a class similar to Singleton to deal with common operations in the set of prime numbers that I will need to complete projecteuler.net's problems.

I am interested in the feedback for all aspects of the implementation (except for the actual main generation algorithms, the 6 * i +/- 1 The method was used solely for its simplicity).

I am also interested in comments on how the interfaces are divided. I divided them into parts of functionality in an attempt to allow future changes in the implementation. I'm planning to use DI (for example, SimpleInjector) to link the singleton instance to each of the interfaces, but I'm starting to doubt this pattern.

I am less interested in the comments on the method selections, I simply chose a relatively minimal subset of methods that I know I will need at some point; more methods will probably be added as necessary.

Interfaces

public interface IPrimeGenerator
{
Enumerable PrimesUntilValue (long value);
Enumerable PrimesUntilCount (int account);
}

public interface IPrimeGenerator
{
Enumerable PrimesUntilValue (long value);
Enumerable PrimesUntilCount (int account);
}

public interface IPrimeFactorizer
{
Enumerable PrimeFactors (long value);
Enumerable UniquePrimeFactors (long value);
}

Implementation

public class PrimeEngine: IPrimeGenerator, IPrimeChecker, IPrimeFactorizer
{
private readollly ICollection _primeCollection;
long private _indexFactor;
Private long _maxChecked;

PrimeEngine public ()
{
_primeCollection = new collection {2. 3};
_indexFactor = 1;
_maxChecked = 3;
}

Private vacuum CheckNextPossiblePrimeDoublet ()
{
var low = 6 * _indexFactor - 1;
var high = low + 2;

if (IsPrime (low))
{
_primeCollection.Add (low);
}

if (IsPrime (high))
{
_primeCollection.Add (high);
}

_indexFactor + = 1;
_maxChecked = high;
}

IEnumerable private GetPossibleSmallerPrimeFactors (long value)
{
FillPrimesUntilRoot (value);
return PrimesUntilRoot (value);
}

public bool IsPrime (long value)
{
var primePool = GetPossibleSmallerPrimeFactors (value);
returns primePool.All (prime => value% prime! = 0);
}

Private void FillPrimesUntilValue (long value)
{
while (_maxChecked <value)
{
CheckNextPossiblePrimeDoublet ();
}
}

private void FillPrimesUntilCount (int account)
{
while (_primeCollection.Count <count)
{
CheckNextPossiblePrimeDoublet ();
}
}

static long FloorOfRoot (long value)
{
return (long) Math.Floor (Math.Sqrt (value));
}

Private vacuum FillPrimesUntilRoot (long value)
{
FillPrimesUntilValue (FloorOfRoot (value));
}

IEnumerable public PrimesUntilValue (long value)
{
FillPrimesUntilValue (value);
returns _primeCollection.TakeWhile (prime => prime <= value);
}

IEnumerable public PrimesUntilCount (int account)
{
FillPrimesUntilCount (count);
return _primeCollection.Take (count);
}

IEnumerable public PrimesUntilRoot (long value)
{
return PrimesUntilValue (FloorOfRoot (value));
}

IEnumerable public PrimeFactors (long value)
{
FillPrimesUntilRoot (value);
foreach (var prime in PrimesUntilRoot (value))
{
if (prime> value) break;

while (value% prime == 0)
{
performance performance prime
value / = cousin;
}
}

yes (value! = 1)
{
yield return value;
}
}

IEnumerable public UniquePrimeFactors (long value)
{
returns PrimeFactors (value) .Distinct ();
}
}