fact stringlengths 6 3.84k | type stringclasses 11 values | library stringclasses 32 values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
mul_one (a : R) : a * (nat_lit 1).rawCast = a := by simp [Nat.rawCast] | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | mul_one | null |
mul_pf_left (a₁ : R) (a₂) (_ : a₃ * b = c) :
(a₁ ^ a₂ * a₃ : R) * b = a₁ ^ a₂ * c := by
subst_vars; rw [mul_assoc] | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | mul_pf_left | null |
mul_pf_right (b₁ : R) (b₂) (_ : a * b₃ = c) :
a * (b₁ ^ b₂ * b₃) = b₁ ^ b₂ * c := by
subst_vars; rw [mul_left_comm] | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | mul_pf_right | null |
mul_pp_pf_overlap {ea eb e : ℕ} (x : R) (_ : ea + eb = e) (_ : a₂ * b₂ = c) :
(x ^ ea * a₂ : R) * (x ^ eb * b₂) = x ^ e * c := by
subst_vars; simp [pow_add, mul_mul_mul_comm] | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | mul_pp_pf_overlap | null |
partial evalMulProd {a b : Q($α)} (va : ExProd sα a) (vb : ExProd sα b) :
MetaM <| Result (ExProd sα) q($a * $b) := do
Lean.Core.checkSystem decl_name%.toString
match va, vb with
| .const za ha, .const zb hb =>
if za = 1 then
return ⟨b, .const zb hb, (q(one_mul $b) : Expr)⟩
else if zb = 1 then
return ⟨a, .const za ha, (q(mul_one $a) : Expr)⟩
else
let ra := Result.ofRawRat za a ha; let rb := Result.ofRawRat zb b hb
let rc ← ra.mul rb
let ⟨zc, hc⟩ := rc.toRatNZ.get!
let ⟨c, pc⟩ := rc.toRawEq
return ⟨c, .const zc hc, pc⟩
| .mul (x := a₁) (e := a₂) va₁ va₂ va₃, .const _ _ =>
let ⟨_, vc, pc⟩ ← evalMulProd va₃ vb
return ⟨_, .mul va₁ va₂ vc, (q(mul_pf_left $a₁ $a₂ $pc) : Expr)⟩
| .const _ _, .mul (x := b₁) (e := b₂) vb₁ vb₂ vb₃ =>
let ⟨_, vc, pc⟩ ← evalMulProd va vb₃
return ⟨_, .mul vb₁ vb₂ vc, (q(mul_pf_right $b₁ $b₂ $pc) : Expr)⟩
| .mul (x := xa) (e := ea) vxa vea va₂, .mul (x := xb) (e := eb) vxb veb vb₂ => do
if vxa.eq vxb then
if let some (.nonzero ⟨_, ve, pe⟩) ← (evalAddOverlap sℕ vea veb).run then
let ⟨_, vc, pc⟩ ← evalMulProd va₂ vb₂
return ⟨_, .mul vxa ve vc, (q(mul_pp_pf_overlap $xa $pe $pc) : Expr)⟩
if let .lt := (vxa.cmp vxb).then (vea.cmp veb) then
let ⟨_, vc, pc⟩ ← evalMulProd va₂ vb
return ⟨_, .mul vxa vea vc, (q(mul_pf_left $xa $ea $pc) : Expr)⟩
else
let ⟨_, vc, pc⟩ ← evalMulProd va vb₂
return ⟨_, .mul vxb veb vc, (q(mul_pf_right $xb $eb $pc) : Expr)⟩ | def | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | evalMulProd | Multiplies two monomials `va, vb` together to get a normalized result monomial.
* `x * y = (x * y)` (for `x`, `y` coefficients)
* `x * (b₁ * b₂) = b₁ * (b₂ * x)` (for `x` coefficient)
* `(a₁ * a₂) * y = a₁ * (a₂ * y)` (for `y` coefficient)
* `(x ^ ea * a₂) * (x ^ eb * b₂) = x ^ (ea + eb) * (a₂ * b₂)`
(if `ea` and `eb` are identical except coefficient)
* `(a₁ * a₂) * (b₁ * b₂) = a₁ * (a₂ * (b₁ * b₂))` (if `a₁.lt b₁`)
* `(a₁ * a₂) * (b₁ * b₂) = b₁ * ((a₁ * a₂) * b₂)` (if not `a₁.lt b₁`) |
mul_zero (a : R) : a * 0 = 0 := by simp | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | mul_zero | null |
mul_add {d : R} (_ : (a : R) * b₁ = c₁) (_ : a * b₂ = c₂) (_ : c₁ + 0 + c₂ = d) :
a * (b₁ + b₂) = d := by
subst_vars; simp [_root_.mul_add] | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | mul_add | null |
evalMul₁ {a b : Q($α)} (va : ExProd sα a) (vb : ExSum sα b) :
MetaM <| Result (ExSum sα) q($a * $b) := do
match vb with
| .zero => return ⟨_, .zero, q(mul_zero $a)⟩
| .add vb₁ vb₂ =>
let ⟨_, vc₁, pc₁⟩ ← evalMulProd sα va vb₁
let ⟨_, vc₂, pc₂⟩ ← evalMul₁ va vb₂
let ⟨_, vd, pd⟩ ← evalAdd sα vc₁.toSum vc₂
return ⟨_, vd, q(mul_add $pc₁ $pc₂ $pd)⟩ | def | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | evalMul₁ | Multiplies a monomial `va` to a polynomial `vb` to get a normalized result polynomial.
* `a * 0 = 0`
* `a * (b₁ + b₂) = (a * b₁) + (a * b₂)` |
zero_mul (b : R) : 0 * b = 0 := by simp | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | zero_mul | null |
add_mul {d : R} (_ : (a₁ : R) * b = c₁) (_ : a₂ * b = c₂) (_ : c₁ + c₂ = d) :
(a₁ + a₂) * b = d := by subst_vars; simp [_root_.add_mul] | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | add_mul | null |
evalMul {a b : Q($α)} (va : ExSum sα a) (vb : ExSum sα b) :
MetaM <| Result (ExSum sα) q($a * $b) := do
match va with
| .zero => return ⟨_, .zero, q(zero_mul $b)⟩
| .add va₁ va₂ =>
let ⟨_, vc₁, pc₁⟩ ← evalMul₁ sα va₁ vb
let ⟨_, vc₂, pc₂⟩ ← evalMul va₂ vb
let ⟨_, vd, pd⟩ ← evalAdd sα vc₁ vc₂
return ⟨_, vd, q(add_mul $pc₁ $pc₂ $pd)⟩
/-! ### Scalar multiplication by `ℕ` -/ | def | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | evalMul | Multiplies two polynomials `va, vb` together to get a normalized result polynomial.
* `0 * b = 0`
* `(a₁ + a₂) * b = (a₁ * b) + (a₂ * b)` |
natCast_nat (n) : ((Nat.rawCast n : ℕ) : R) = Nat.rawCast n := by simp | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | natCast_nat | null |
natCast_mul {a₁ a₃ : ℕ} (a₂) (_ : ((a₁ : ℕ) : R) = b₁)
(_ : ((a₃ : ℕ) : R) = b₃) : ((a₁ ^ a₂ * a₃ : ℕ) : R) = b₁ ^ a₂ * b₃ := by
subst_vars; simp | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | natCast_mul | null |
natCast_zero : ((0 : ℕ) : R) = 0 := Nat.cast_zero | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | natCast_zero | null |
natCast_add {a₁ a₂ : ℕ}
(_ : ((a₁ : ℕ) : R) = b₁) (_ : ((a₂ : ℕ) : R) = b₂) : ((a₁ + a₂ : ℕ) : R) = b₁ + b₂ := by
subst_vars; simp
mutual | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | natCast_add | null |
partial ExBase.evalNatCast {a : Q(ℕ)} (va : ExBase sℕ a) : AtomM (Result (ExBase sα) q($a)) :=
match va with
| .atom _ => do
let (i, ⟨b', _⟩) ← addAtomQ q($a)
pure ⟨b', ExBase.atom i, q(Eq.refl $b')⟩
| .sum va => do
let ⟨_, vc, p⟩ ← va.evalNatCast
pure ⟨_, .sum vc, p⟩ | def | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | ExBase.evalNatCast | Applies `Nat.cast` to a nat polynomial to produce a polynomial in `α`.
* An atom `e` causes `↑e` to be allocated as a new atom.
* A sum delegates to `ExSum.evalNatCast`. |
partial ExProd.evalNatCast {a : Q(ℕ)} (va : ExProd sℕ a) : AtomM (Result (ExProd sα) q($a)) :=
match va with
| .const c hc =>
have n : Q(ℕ) := a.appArg!
pure ⟨q(Nat.rawCast $n), .const c hc, (q(natCast_nat (R := $α) $n) : Expr)⟩
| .mul (e := a₂) va₁ va₂ va₃ => do
let ⟨_, vb₁, pb₁⟩ ← va₁.evalNatCast
let ⟨_, vb₃, pb₃⟩ ← va₃.evalNatCast
pure ⟨_, .mul vb₁ va₂ vb₃, q(natCast_mul $a₂ $pb₁ $pb₃)⟩ | def | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | ExProd.evalNatCast | Applies `Nat.cast` to a nat monomial to produce a monomial in `α`.
* `↑c = c` if `c` is a numeric literal
* `↑(a ^ n * b) = ↑a ^ n * ↑b` |
partial ExSum.evalNatCast {a : Q(ℕ)} (va : ExSum sℕ a) : AtomM (Result (ExSum sα) q($a)) :=
match va with
| .zero => pure ⟨_, .zero, q(natCast_zero (R := $α))⟩
| .add va₁ va₂ => do
let ⟨_, vb₁, pb₁⟩ ← va₁.evalNatCast
let ⟨_, vb₂, pb₂⟩ ← va₂.evalNatCast
pure ⟨_, .add vb₁ vb₂, q(natCast_add $pb₁ $pb₂)⟩ | def | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | ExSum.evalNatCast | Applies `Nat.cast` to a nat polynomial to produce a polynomial in `α`.
* `↑0 = 0`
* `↑(a + b) = ↑a + ↑b` |
smul_nat {a b c : ℕ} (_ : (a * b : ℕ) = c) : a • b = c := by subst_vars; simp | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | smul_nat | null |
smul_eq_cast {a : ℕ} (_ : ((a : ℕ) : R) = a') (_ : a' * b = c) : a • b = c := by
subst_vars; simp | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | smul_eq_cast | null |
evalNSMul {a : Q(ℕ)} {b : Q($α)} (va : ExSum sℕ a) (vb : ExSum sα b) :
AtomM (Result (ExSum sα) q($a • $b)) := do
if ← isDefEq sα sℕ then
let ⟨_, va'⟩ := va.cast
have _b : Q(ℕ) := b
let ⟨(_c : Q(ℕ)), vc, (pc : Q($a * $_b = $_c))⟩ ← evalMul sα va' vb
pure ⟨_, vc, (q(smul_nat $pc) : Expr)⟩
else
let ⟨_, va', pa'⟩ ← va.evalNatCast sα
let ⟨_, vc, pc⟩ ← evalMul sα va' vb
pure ⟨_, vc, (q(smul_eq_cast $pa' $pc) : Expr)⟩
/-! ### Scalar multiplication by `ℤ` -/ | def | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | evalNSMul | Constructs the scalar multiplication `n • a`, where both `n : ℕ` and `a : α` are normalized
polynomial expressions.
* `a • b = a * b` if `α = ℕ`
* `a • b = ↑a * b` otherwise |
natCast_int {R} [Ring R] (n) : ((Nat.rawCast n : ℤ) : R) = Nat.rawCast n := by simp | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | natCast_int | null |
intCast_negOfNat_Int {R} [Ring R] (n) :
((Int.rawCast (Int.negOfNat n) : ℤ) : R) = Int.rawCast (Int.negOfNat n) := by simp | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | intCast_negOfNat_Int | null |
intCast_mul {R} [Ring R] {b₁ b₃ : R} {a₁ a₃ : ℤ} (a₂) (_ : ((a₁ : ℤ) : R) = b₁)
(_ : ((a₃ : ℤ) : R) = b₃) : ((a₁ ^ a₂ * a₃ : ℤ) : R) = b₁ ^ a₂ * b₃ := by
subst_vars; simp | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | intCast_mul | null |
intCast_zero {R} [Ring R] : ((0 : ℤ) : R) = 0 := Int.cast_zero | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | intCast_zero | null |
intCast_add {R} [Ring R] {b₁ b₂ : R} {a₁ a₂ : ℤ}
(_ : ((a₁ : ℤ) : R) = b₁) (_ : ((a₂ : ℤ) : R) = b₂) : ((a₁ + a₂ : ℤ) : R) = b₁ + b₂ := by
subst_vars; simp
mutual | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | intCast_add | null |
partial ExBase.evalIntCast {a : Q(ℤ)} (rα : Q(Ring $α)) (va : ExBase sℤ a) :
AtomM (Result (ExBase sα) q($a)) :=
match va with
| .atom _ => do
let (i, ⟨b', _⟩) ← addAtomQ q($a)
pure ⟨b', ExBase.atom i, q(Eq.refl $b')⟩
| .sum va => do
let ⟨_, vc, p⟩ ← va.evalIntCast rα
pure ⟨_, .sum vc, p⟩ | def | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | ExBase.evalIntCast | Applies `Int.cast` to an int polynomial to produce a polynomial in `α`.
* An atom `e` causes `↑e` to be allocated as a new atom.
* A sum delegates to `ExSum.evalIntCast`. |
partial ExProd.evalIntCast {a : Q(ℤ)} (rα : Q(Ring $α)) (va : ExProd sℤ a) :
AtomM (Result (ExProd sα) q($a)) :=
match va with
| .const c hc => do
match a with
| ~q(Nat.rawCast $m) =>
pure ⟨q(Nat.rawCast $m), .const c hc, q(natCast_int (R := $α) $m)⟩
| ~q(Int.rawCast (Int.negOfNat $m)) =>
pure ⟨q(Int.rawCast (Int.negOfNat $m)), .const c hc, q(intCast_negOfNat_Int (R := $α) $m)⟩
| .mul (e := a₂) va₁ va₂ va₃ => do
let ⟨_, vb₁, pb₁⟩ ← va₁.evalIntCast rα
let ⟨_, vb₃, pb₃⟩ ← va₃.evalIntCast rα
let pf ← mkAppM ``intCast_mul #[a₂, pb₁, pb₃]
pure ⟨_, .mul vb₁ va₂ vb₃, pf⟩ | def | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | ExProd.evalIntCast | Applies `Int.cast` to an int monomial to produce a monomial in `α`.
* `↑c = c` if `c` is a numeric literal
* `↑(a ^ n * b) = ↑a ^ n * ↑b` |
partial ExSum.evalIntCast {a : Q(ℤ)} (rα : Q(Ring $α)) (va : ExSum sℤ a) :
AtomM (Result (ExSum sα) q($a)) :=
match va with
| .zero => do
let pf ← mkAppOptM ``intCast_zero #[α, none]
pure ⟨_, .zero, pf⟩
| .add va₁ va₂ => do
let ⟨_, vb₁, pb₁⟩ ← va₁.evalIntCast rα
let ⟨_, vb₂, pb₂⟩ ← va₂.evalIntCast rα
let pf ← mkAppM ``intCast_add #[pb₁, pb₂]
pure ⟨_, .add vb₁ vb₂, pf⟩ | def | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | ExSum.evalIntCast | Applies `Int.cast` to an int polynomial to produce a polynomial in `α`.
* `↑0 = 0`
* `↑(a + b) = ↑a + ↑b` |
smul_int {a b c : ℤ} (_ : (a * b : ℤ) = c) : a • b = c := by subst_vars; simp | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | smul_int | null |
smul_eq_intCast {R} [Ring R] {a' b c : R} {a : ℤ} (_ : ((a : ℤ) : R) = a')
(_ : a' * b = c) : a • b = c := by
subst_vars; simp | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | smul_eq_intCast | null |
evalZSMul {a : Q(ℤ)} {b : Q($α)} (rα : Q(Ring $α)) (va : ExSum sℤ a) (vb : ExSum sα b) :
AtomM (Result (ExSum sα) q($a • $b)) := do
if ← isDefEq sα sℤ then
let ⟨_, va'⟩ := va.cast
have _b : Q(ℤ) := b
let ⟨(_c : Q(ℤ)), vc, (pc : Q($a * $_b = $_c))⟩ ← evalMul sα va' vb
pure ⟨_, vc, (q(smul_int $pc) : Expr)⟩
else
let ⟨_, va', pa'⟩ ← va.evalIntCast sα rα
let ⟨_, vc, pc⟩ ← evalMul sα va' vb
let pf ← mkAppM ``smul_eq_intCast #[pa', pc]
pure ⟨_, vc, pf⟩
/-! ### Negation -/ | def | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | evalZSMul | Constructs the scalar multiplication `n • a`, where both `n : ℤ` and `a : α` are normalized
polynomial expressions.
* `a • b = a * b` if `α = ℤ`
* `a • b = a' * b` otherwise, where `a'` is `↑a` with the coercion pushed as deep as possible. |
neg_one_mul {R} [Ring R] {a b : R} (_ : (Int.negOfNat (nat_lit 1)).rawCast * a = b) :
-a = b := by subst_vars; simp [Int.negOfNat] | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | neg_one_mul | null |
neg_mul {R} [Ring R] (a₁ : R) (a₂) {a₃ b : R}
(_ : -a₃ = b) : -(a₁ ^ a₂ * a₃) = a₁ ^ a₂ * b := by subst_vars; simp | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | neg_mul | null |
evalNegProd {a : Q($α)} (rα : Q(Ring $α)) (va : ExProd sα a) :
MetaM <| Result (ExProd sα) q(-$a) := do
Lean.Core.checkSystem decl_name%.toString
match va with
| .const za ha =>
let ⟨m1, _⟩ := ExProd.mkNegNat sα rα 1
let rm := Result.isNegNat rα q(nat_lit 1) q(IsInt.of_raw $α (.negOfNat (nat_lit 1)))
let ra := Result.ofRawRat za a ha
let rb ← rm.mul ra
let ⟨zb, hb⟩ := rb.toRatNZ.get!
let ⟨b, pb⟩ := rb.toRawEq
have pb : Q(((Int.negOfNat (nat_lit 1)).rawCast : $α) * $a = $b) := pb
return ⟨b, .const zb hb, q(neg_one_mul (R := $α) $pb)⟩
| .mul (x := a₁) (e := a₂) va₁ va₂ va₃ =>
let ⟨_, vb, pb⟩ ← evalNegProd rα va₃
return ⟨_, .mul va₁ va₂ vb, (q(neg_mul $a₁ $a₂ $pb) : Expr)⟩ | def | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | evalNegProd | Negates a monomial `va` to get another monomial.
* `-c = (-c)` (for `c` coefficient)
* `-(a₁ * a₂) = a₁ * -a₂` |
neg_zero {R} [Ring R] : -(0 : R) = 0 := by simp | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | neg_zero | null |
neg_add {R} [Ring R] {a₁ a₂ b₁ b₂ : R}
(_ : -a₁ = b₁) (_ : -a₂ = b₂) : -(a₁ + a₂) = b₁ + b₂ := by
subst_vars; simp [add_comm] | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | neg_add | null |
evalNeg {a : Q($α)} (rα : Q(Ring $α)) (va : ExSum sα a) :
MetaM <| Result (ExSum sα) q(-$a) := do
match va with
| .zero => return ⟨_, .zero, (q(neg_zero (R := $α)) : Expr)⟩
| .add va₁ va₂ =>
let ⟨_, vb₁, pb₁⟩ ← evalNegProd sα rα va₁
let ⟨_, vb₂, pb₂⟩ ← evalNeg rα va₂
return ⟨_, .add vb₁ vb₂, (q(neg_add $pb₁ $pb₂) : Expr)⟩
/-! ### Subtraction -/ | def | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | evalNeg | Negates a polynomial `va` to get another polynomial.
* `-0 = 0` (for `c` coefficient)
* `-(a₁ + a₂) = -a₁ + -a₂` |
sub_pf {R} [Ring R] {a b c d : R}
(_ : -b = c) (_ : a + c = d) : a - b = d := by subst_vars; simp [sub_eq_add_neg] | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | sub_pf | null |
evalSub {α : Q(Type u)} (sα : Q(CommSemiring $α)) {a b : Q($α)}
(rα : Q(Ring $α)) (va : ExSum sα a) (vb : ExSum sα b) :
MetaM <| Result (ExSum sα) q($a - $b) := do
let ⟨_c, vc, pc⟩ ← evalNeg sα rα vb
let ⟨d, vd, (pd : Q($a + $_c = $d))⟩ ← evalAdd sα va vc
return ⟨d, vd, (q(sub_pf $pc $pd) : Expr)⟩
/-! ### Exponentiation -/ | def | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | evalSub | Subtracts two polynomials `va, vb` to get a normalized result polynomial.
* `a - b = a + -b` |
pow_prod_atom (a : R) (b) : a ^ b = (a + 0) ^ b * (nat_lit 1).rawCast := by simp | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | pow_prod_atom | null |
evalPowProdAtom {a : Q($α)} {b : Q(ℕ)} (va : ExProd sα a) (vb : ExProd sℕ b) :
Result (ExProd sα) q($a ^ $b) :=
⟨_, (ExBase.sum va.toSum).toProd vb, q(pow_prod_atom $a $b)⟩ | def | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | evalPowProdAtom | The fallback case for exponentiating polynomials is to use `ExBase.toProd` to just build an
exponent expression. (This has a slightly different normalization than `evalPowAtom` because
the input types are different.)
* `x ^ e = (x + 0) ^ e * 1` |
pow_atom (a : R) (b) : a ^ b = a ^ b * (nat_lit 1).rawCast + 0 := by simp | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | pow_atom | null |
evalPowAtom {a : Q($α)} {b : Q(ℕ)} (va : ExBase sα a) (vb : ExProd sℕ b) :
Result (ExSum sα) q($a ^ $b) :=
⟨_, (va.toProd vb).toSum, q(pow_atom $a $b)⟩ | def | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | evalPowAtom | The fallback case for exponentiating polynomials is to use `ExBase.toProd` to just build an
exponent expression.
* `x ^ e = x ^ e * 1 + 0` |
const_pos (n : ℕ) (h : Nat.ble 1 n = true) : 0 < (n.rawCast : ℕ) := Nat.le_of_ble_eq_true h | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | const_pos | null |
mul_exp_pos {a₁ a₂ : ℕ} (n) (h₁ : 0 < a₁) (h₂ : 0 < a₂) : 0 < a₁ ^ n * a₂ :=
Nat.mul_pos (Nat.pow_pos h₁) h₂ | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | mul_exp_pos | null |
add_pos_left {a₁ : ℕ} (a₂) (h : 0 < a₁) : 0 < a₁ + a₂ :=
Nat.lt_of_lt_of_le h (Nat.le_add_right ..) | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | add_pos_left | null |
add_pos_right {a₂ : ℕ} (a₁) (h : 0 < a₂) : 0 < a₁ + a₂ :=
Nat.lt_of_lt_of_le h (Nat.le_add_left ..)
mutual | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | add_pos_right | null |
partial ExBase.evalPos {a : Q(ℕ)} (va : ExBase sℕ a) : Option Q(0 < $a) :=
match va with
| .atom _ => none
| .sum va => va.evalPos | def | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | ExBase.evalPos | Attempts to prove that a polynomial expression in `ℕ` is positive.
* Atoms are not (necessarily) positive
* Sums defer to `ExSum.evalPos` |
partial ExProd.evalPos {a : Q(ℕ)} (va : ExProd sℕ a) : Option Q(0 < $a) :=
match va with
| .const _ _ =>
have lit : Q(ℕ) := a.appArg!
haveI : $a =Q Nat.rawCast $lit := ⟨⟩
haveI p : Nat.ble 1 $lit =Q true := ⟨⟩
some q(const_pos $lit $p)
| .mul (e := ea₁) vxa₁ _ va₂ => do
let pa₁ ← vxa₁.evalPos
let pa₂ ← va₂.evalPos
some q(mul_exp_pos $ea₁ $pa₁ $pa₂) | def | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | ExProd.evalPos | Attempts to prove that a monomial expression in `ℕ` is positive.
* `0 < c` (where `c` is a numeral) is true by the normalization invariant (`c` is not zero)
* `0 < x ^ e * b` if `0 < x` and `0 < b` |
partial ExSum.evalPos {a : Q(ℕ)} (va : ExSum sℕ a) : Option Q(0 < $a) :=
match va with
| .zero => none
| .add (a := a₁) (b := a₂) va₁ va₂ => do
match va₁.evalPos with
| some p => some q(add_pos_left $a₂ $p)
| none => let p ← va₂.evalPos; some q(add_pos_right $a₁ $p) | def | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | ExSum.evalPos | Attempts to prove that a polynomial expression in `ℕ` is positive.
* `0 < 0` fails
* `0 < a + b` if `0 < a` or `0 < b` |
pow_one (a : R) : a ^ nat_lit 1 = a := by simp | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | pow_one | null |
pow_bit0 {k : ℕ} (_ : (a : R) ^ k = b) (_ : b * b = c) :
a ^ (Nat.mul (nat_lit 2) k) = c := by
subst_vars; simp [Nat.succ_mul, pow_add] | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | pow_bit0 | null |
pow_bit1 {k : ℕ} {d : R} (_ : (a : R) ^ k = b) (_ : b * b = c) (_ : c * a = d) :
a ^ (Nat.add (Nat.mul (nat_lit 2) k) (nat_lit 1)) = d := by
subst_vars; simp [Nat.succ_mul, pow_add] | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | pow_bit1 | null |
partial evalPowNat {a : Q($α)} (va : ExSum sα a) (n : Q(ℕ)) :
MetaM <| Result (ExSum sα) q($a ^ $n) := do
let nn := n.natLit!
if nn = 1 then
return ⟨_, va, (q(pow_one $a) : Expr)⟩
else
let nm := nn >>> 1
have m : Q(ℕ) := mkRawNatLit nm
if nn &&& 1 = 0 then
let ⟨_, vb, pb⟩ ← evalPowNat va m
let ⟨_, vc, pc⟩ ← evalMul sα vb vb
return ⟨_, vc, (q(pow_bit0 $pb $pc) : Expr)⟩
else
let ⟨_, vb, pb⟩ ← evalPowNat va m
let ⟨_, vc, pc⟩ ← evalMul sα vb vb
let ⟨_, vd, pd⟩ ← evalMul sα vc va
return ⟨_, vd, (q(pow_bit1 $pb $pc $pd) : Expr)⟩ | def | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | evalPowNat | The main case of exponentiation of ring expressions is when `va` is a polynomial and `n` is a
nonzero literal expression, like `(x + y)^5`. In this case we work out the polynomial completely
into a sum of monomials.
* `x ^ 1 = x`
* `x ^ (2*n) = x ^ n * x ^ n`
* `x ^ (2*n+1) = x ^ n * x ^ n * x` |
one_pow (b : ℕ) : ((nat_lit 1).rawCast : R) ^ b = (nat_lit 1).rawCast := by simp | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | one_pow | null |
mul_pow {ea₁ b c₁ : ℕ} {xa₁ : R}
(_ : ea₁ * b = c₁) (_ : a₂ ^ b = c₂) : (xa₁ ^ ea₁ * a₂ : R) ^ b = xa₁ ^ c₁ * c₂ := by
subst_vars; simp [_root_.mul_pow, pow_mul] | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | mul_pow | null |
evalPowProd {a : Q($α)} {b : Q(ℕ)} (va : ExProd sα a) (vb : ExProd sℕ b) :
MetaM <| Result (ExProd sα) q($a ^ $b) := do
Lean.Core.checkSystem decl_name%.toString
let res : OptionT MetaM (Result (ExProd sα) q($a ^ $b)) := do
match va, vb with
| .const 1, _ => return ⟨_, va, (q(one_pow (R := $α) $b) : Expr)⟩
| .const za ha, .const zb hb =>
assert! 0 ≤ zb
let ra := Result.ofRawRat za a ha
have lit : Q(ℕ) := b.appArg!
let rb := (q(IsNat.of_raw ℕ $lit) : Expr)
let rc ← NormNum.evalPow.core q($a ^ $b) q(HPow.hPow) q($a) q($b) lit rb
q(CommSemiring.toSemiring) ra
let ⟨zc, hc⟩ ← rc.toRatNZ
let ⟨c, pc⟩ := rc.toRawEq
return ⟨c, .const zc hc, pc⟩
| .mul vxa₁ vea₁ va₂, vb =>
let ⟨_, vc₁, pc₁⟩ ← evalMulProd sℕ vea₁ vb
let ⟨_, vc₂, pc₂⟩ ← evalPowProd va₂ vb
return ⟨_, .mul vxa₁ vc₁ vc₂, q(mul_pow $pc₁ $pc₂)⟩
| _, _ => OptionT.fail
return (← res.run).getD (evalPowProdAtom sα va vb) | def | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | evalPowProd | There are several special cases when exponentiating monomials:
* `1 ^ n = 1`
* `x ^ y = (x ^ y)` when `x` and `y` are constants
* `(a * b) ^ e = a ^ e * b ^ e`
In all other cases we use `evalPowProdAtom`. |
ExtractCoeff (e : Q(ℕ)) where
/-- A raw natural number literal. -/
k : Q(ℕ)
/-- The result of extracting the coefficient is a monic monomial. -/
e' : Q(ℕ)
/-- `e'` is a monomial. -/
ve' : ExProd sℕ e'
/-- The proof that `e` splits into the coefficient `k` and the monic monomial `e'`. -/
p : Q($e = $e' * $k) | structure | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | ExtractCoeff | The result of `extractCoeff` is a numeral and a proof that the original expression
factors by this numeral. |
coeff_one (k : ℕ) : k.rawCast = (nat_lit 1).rawCast * k := by simp | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | coeff_one | null |
coeff_mul {a₃ c₂ k : ℕ}
(a₁ a₂ : ℕ) (_ : a₃ = c₂ * k) : a₁ ^ a₂ * a₃ = (a₁ ^ a₂ * c₂) * k := by
subst_vars; rw [mul_assoc] | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | coeff_mul | null |
extractCoeff {a : Q(ℕ)} (va : ExProd sℕ a) : ExtractCoeff a :=
match va with
| .const _ _ =>
have k : Q(ℕ) := a.appArg!
⟨k, q((nat_lit 1).rawCast), .const 1, (q(coeff_one $k) : Expr)⟩
| .mul (x := a₁) (e := a₂) va₁ va₂ va₃ =>
let ⟨k, _, vc, pc⟩ := extractCoeff va₃
⟨k, _, .mul va₁ va₂ vc, q(coeff_mul $a₁ $a₂ $pc)⟩ | def | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | extractCoeff | Given a monomial expression `va`, splits off the leading coefficient `k` and the remainder
`e'`, stored in the `ExtractCoeff` structure.
* `c = 1 * c` (if `c` is a constant)
* `a * b = (a * b') * k` if `b = b' * k` |
pow_one_cast (a : R) : a ^ (nat_lit 1).rawCast = a := by simp | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | pow_one_cast | null |
zero_pow {b : ℕ} (_ : 0 < b) : (0 : R) ^ b = 0 := match b with | b+1 => by simp [pow_succ] | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | zero_pow | null |
single_pow {b : ℕ} (_ : (a : R) ^ b = c) : (a + 0) ^ b = c + 0 := by
simp [*] | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | single_pow | null |
pow_nat {b c k : ℕ} {d e : R} (_ : b = c * k) (_ : a ^ c = d) (_ : d ^ k = e) :
(a : R) ^ b = e := by
subst_vars; simp [pow_mul] | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | pow_nat | null |
partial evalPow₁ {a : Q($α)} {b : Q(ℕ)} (va : ExSum sα a) (vb : ExProd sℕ b) :
MetaM <| Result (ExSum sα) q($a ^ $b) := do
match va, vb with
| va, .const 1 =>
haveI : $b =Q Nat.rawCast (nat_lit 1) := ⟨⟩
return ⟨_, va, q(pow_one_cast $a)⟩
| .zero, vb => match vb.evalPos with
| some p => return ⟨_, .zero, q(zero_pow (R := $α) $p)⟩
| none => return evalPowAtom sα (.sum .zero) vb
| ExSum.add va .zero, vb => -- TODO: using `.add` here takes a while to compile?
let ⟨_, vc, pc⟩ ← evalPowProd sα va vb
return ⟨_, vc.toSum, q(single_pow $pc)⟩
| va, vb =>
if vb.coeff > 1 then
let ⟨k, _, vc, pc⟩ := extractCoeff vb
let ⟨_, vd, pd⟩ ← evalPow₁ va vc
let ⟨_, ve, pe⟩ ← evalPowNat sα vd k
return ⟨_, ve, q(pow_nat $pc $pd $pe)⟩
else
return evalPowAtom sα (.sum va) vb | def | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | evalPow₁ | Exponentiates a polynomial `va` by a monomial `vb`, including several special cases.
* `a ^ 1 = a`
* `0 ^ e = 0` if `0 < e`
* `(a + 0) ^ b = a ^ b` computed using `evalPowProd`
* `a ^ b = (a ^ b') ^ k` if `b = b' * k` and `k > 1`
Otherwise `a ^ b` is just encoded as `a ^ b * 1 + 0` using `evalPowAtom`. |
pow_zero (a : R) : a ^ 0 = (nat_lit 1).rawCast + 0 := by simp | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | pow_zero | null |
pow_add {b₁ b₂ : ℕ} {d : R}
(_ : a ^ b₁ = c₁) (_ : a ^ b₂ = c₂) (_ : c₁ * c₂ = d) : (a : R) ^ (b₁ + b₂) = d := by
subst_vars; simp [_root_.pow_add] | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | pow_add | null |
evalPow {a : Q($α)} {b : Q(ℕ)} (va : ExSum sα a) (vb : ExSum sℕ b) :
MetaM <| Result (ExSum sα) q($a ^ $b) := do
match vb with
| .zero => return ⟨_, (ExProd.mkNat sα 1).2.toSum, q(pow_zero $a)⟩
| .add vb₁ vb₂ =>
let ⟨_, vc₁, pc₁⟩ ← evalPow₁ sα va vb₁
let ⟨_, vc₂, pc₂⟩ ← evalPow va vb₂
let ⟨_, vd, pd⟩ ← evalMul sα vc₁ vc₂
return ⟨_, vd, q(pow_add $pc₁ $pc₂ $pd)⟩ | def | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | evalPow | Exponentiates two polynomials `va, vb`.
* `a ^ 0 = 1`
* `a ^ (b₁ + b₂) = a ^ b₁ * a ^ b₂` |
Cache {α : Q(Type u)} (sα : Q(CommSemiring $α)) where
/-- A ring instance on `α`, if available. -/
rα : Option Q(Ring $α)
/-- A division semiring instance on `α`, if available. -/
dsα : Option Q(DivisionSemiring $α)
/-- A characteristic zero ring instance on `α`, if available. -/
czα : Option Q(CharZero $α) | structure | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | Cache | This cache contains data required by the `ring` tactic during execution. |
mkCache {α : Q(Type u)} (sα : Q(CommSemiring $α)) : MetaM (Cache sα) :=
return {
rα := (← trySynthInstanceQ q(Ring $α)).toOption
dsα := (← trySynthInstanceQ q(DivisionSemiring $α)).toOption
czα := (← trySynthInstanceQ q(CharZero $α)).toOption } | def | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | mkCache | Create a new cache for `α` by doing the necessary instance searches. |
cast_pos {n : ℕ} : IsNat (a : R) n → a = n.rawCast + 0
| ⟨e⟩ => by simp [e] | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | cast_pos | null |
cast_zero : IsNat (a : R) (nat_lit 0) → a = 0
| ⟨e⟩ => by simp [e] | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | cast_zero | null |
cast_neg {n : ℕ} {R} [Ring R] {a : R} :
IsInt a (.negOfNat n) → a = (Int.negOfNat n).rawCast + 0
| ⟨e⟩ => by simp [e] | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | cast_neg | null |
cast_nnrat {n : ℕ} {d : ℕ} {R} [DivisionSemiring R] {a : R} :
IsNNRat a n d → a = NNRat.rawCast n d + 0
| ⟨_, e⟩ => by simp [e, div_eq_mul_inv] | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | cast_nnrat | null |
cast_rat {n : ℤ} {d : ℕ} {R} [DivisionRing R] {a : R} :
IsRat a n d → a = Rat.rawCast n d + 0
| ⟨_, e⟩ => by simp [e, div_eq_mul_inv] | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | cast_rat | null |
evalCast {α : Q(Type u)} (sα : Q(CommSemiring $α)) {e : Q($α)} :
NormNum.Result e → Option (Result (ExSum sα) e)
| .isNat _ (.lit (.natVal 0)) p => do
assumeInstancesCommute
pure ⟨_, .zero, q(cast_zero $p)⟩
| .isNat _ lit p => do
assumeInstancesCommute
pure ⟨_, (ExProd.mkNat sα lit.natLit!).2.toSum, (q(cast_pos $p) :)⟩
| .isNegNat rα lit p =>
pure ⟨_, (ExProd.mkNegNat _ rα lit.natLit!).2.toSum, (q(cast_neg $p) : Expr)⟩
| .isNNRat dsα q n d p =>
pure ⟨_, (ExProd.mkNNRat sα dsα q
n d q(IsNNRat.den_nz $p)).2.toSum, (q(cast_nnrat $p) : Expr)⟩
| .isNegNNRat dα q n d p =>
pure ⟨_, (ExProd.mkNegNNRat sα dα q
n d q(IsRat.den_nz $p)).2.toSum, (q(cast_rat $p) : Expr)⟩
| _ => none | def | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | evalCast | Converts a proof by `norm_num` that `e` is a numeral, into a normalization as a monomial:
* `e = 0` if `norm_num` returns `IsNat e 0`
* `e = Nat.rawCast n + 0` if `norm_num` returns `IsNat e n`
* `e = Int.rawCast n + 0` if `norm_num` returns `IsInt e n`
* `e = NNRat.rawCast n d + 0` if `norm_num` returns `IsNNRat e n d`
* `e = Rat.rawCast n d + 0` if `norm_num` returns `IsRat e n d` |
toProd_pf (p : (a : R) = a') :
a = a' ^ (nat_lit 1).rawCast * (nat_lit 1).rawCast := by simp [*] | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | toProd_pf | null |
atom_pf (a : R) : a = a ^ (nat_lit 1).rawCast * (nat_lit 1).rawCast + 0 := by simp | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | atom_pf | null |
atom_pf' (p : (a : R) = a') :
a = a' ^ (nat_lit 1).rawCast * (nat_lit 1).rawCast + 0 := by simp [*] | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | atom_pf' | null |
evalAtom (e : Q($α)) : AtomM (Result (ExSum sα) e) := do
let r ← (← read).evalAtom e
have e' : Q($α) := r.expr
let (i, ⟨a', _⟩) ← addAtomQ e'
let ve' := (ExBase.atom i (e := a')).toProd (ExProd.mkNat sℕ 1).2 |>.toSum
pure ⟨_, ve', match r.proof? with
| none => (q(atom_pf $e) : Expr)
| some (p : Q($e = $a')) => (q(atom_pf' $p) : Expr)⟩ | def | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | evalAtom | Evaluates an atom, an expression where `ring` can find no additional structure.
* `a = a ^ 1 * 1 + 0` |
inv_mul {R} [DivisionSemiring R] {a₁ a₂ a₃ b₁ b₃ c}
(_ : (a₁⁻¹ : R) = b₁) (_ : (a₃⁻¹ : R) = b₃)
(_ : b₃ * (b₁ ^ a₂ * (nat_lit 1).rawCast) = c) :
(a₁ ^ a₂ * a₃ : R)⁻¹ = c := by subst_vars; simp
nonrec theorem inv_zero {R} [DivisionSemiring R] : (0 : R)⁻¹ = 0 := inv_zero | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | inv_mul | null |
inv_single {R} [DivisionSemiring R] {a b : R}
(_ : (a : R)⁻¹ = b) : (a + 0)⁻¹ = b + 0 := by simp [*] | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | inv_single | null |
inv_add {a₁ a₂ : ℕ} (_ : ((a₁ : ℕ) : R) = b₁) (_ : ((a₂ : ℕ) : R) = b₂) :
((a₁ + a₂ : ℕ) : R) = b₁ + b₂ := by
subst_vars; simp | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | inv_add | null |
evalInvAtom (a : Q($α)) : AtomM (Result (ExBase sα) q($a⁻¹)) := do
let (i, ⟨b', _⟩) ← addAtomQ q($a⁻¹)
pure ⟨b', ExBase.atom i, q(Eq.refl $b')⟩ | def | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | evalInvAtom | Applies `⁻¹` to a polynomial to get an atom. |
ExProd.evalInv {a : Q($α)} (czα : Option Q(CharZero $α)) (va : ExProd sα a) :
AtomM (Result (ExProd sα) q($a⁻¹)) := do
Lean.Core.checkSystem decl_name%.toString
match va with
| .const c hc =>
let ra := Result.ofRawRat c a hc
match ← (Lean.observing? <| ra.inv dsα czα :) with
| some rc =>
let ⟨zc, hc⟩ := rc.toRatNZ.get!
let ⟨c, pc⟩ := rc.toRawEq
pure ⟨c, .const zc hc, pc⟩
| none =>
let ⟨_, vc, pc⟩ ← evalInvAtom sα dsα a
pure ⟨_, vc.toProd (ExProd.mkNat sℕ 1).2, q(toProd_pf $pc)⟩
| .mul (x := a₁) (e := _a₂) _va₁ va₂ va₃ => do
let ⟨_b₁, vb₁, pb₁⟩ ← evalInvAtom sα dsα a₁
let ⟨_b₃, vb₃, pb₃⟩ ← va₃.evalInv czα
let ⟨c, vc, (pc : Q($_b₃ * ($_b₁ ^ $_a₂ * Nat.rawCast 1) = $c))⟩ ←
evalMulProd sα vb₃ (vb₁.toProd va₂)
pure ⟨c, vc, (q(inv_mul $pb₁ $pb₃ $pc) : Expr)⟩ | def | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | ExProd.evalInv | Inverts a polynomial `va` to get a normalized result polynomial.
* `c⁻¹ = (c⁻¹)` if `c` is a constant
* `(a ^ b * c)⁻¹ = a⁻¹ ^ b * c⁻¹` |
ExSum.evalInv {a : Q($α)} (czα : Option Q(CharZero $α)) (va : ExSum sα a) :
AtomM (Result (ExSum sα) q($a⁻¹)) :=
match va with
| ExSum.zero => pure ⟨_, .zero, (q(inv_zero (R := $α)) : Expr)⟩
| ExSum.add va ExSum.zero => do
let ⟨_, vb, pb⟩ ← va.evalInv sα dsα czα
pure ⟨_, vb.toSum, (q(inv_single $pb) : Expr)⟩
| va => do
let ⟨_, vb, pb⟩ ← evalInvAtom sα dsα a
pure ⟨_, vb.toProd (ExProd.mkNat sℕ 1).2 |>.toSum, q(atom_pf' $pb)⟩ | def | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | ExSum.evalInv | Inverts a polynomial `va` to get a normalized result polynomial.
* `0⁻¹ = 0`
* `a⁻¹ = (a⁻¹)` if `a` is a nontrivial sum |
div_pf {R} [DivisionSemiring R] {a b c d : R}
(_ : b⁻¹ = c) (_ : a * c = d) : a / b = d := by
subst_vars; simp [div_eq_mul_inv] | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | div_pf | null |
evalDiv {a b : Q($α)} (rα : Q(DivisionSemiring $α)) (czα : Option Q(CharZero $α))
(va : ExSum sα a) (vb : ExSum sα b) : AtomM (Result (ExSum sα) q($a / $b)) := do
let ⟨_c, vc, pc⟩ ← vb.evalInv sα rα czα
let ⟨d, vd, (pd : Q($a * $_c = $d))⟩ ← evalMul sα va vc
pure ⟨d, vd, q(div_pf $pc $pd)⟩ | def | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | evalDiv | Divides two polynomials `va, vb` to get a normalized result polynomial.
* `a / b = a * b⁻¹` |
add_congr (_ : a = a') (_ : b = b') (_ : a' + b' = c) : (a + b : R) = c := by
subst_vars; rfl | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | add_congr | null |
mul_congr (_ : a = a') (_ : b = b') (_ : a' * b' = c) : (a * b : R) = c := by
subst_vars; rfl | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | mul_congr | null |
nsmul_congr {a a' : ℕ} (_ : (a : ℕ) = a') (_ : b = b') (_ : a' • b' = c) :
(a • (b : R)) = c := by
subst_vars; rfl | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | nsmul_congr | null |
zsmul_congr {R} [Ring R] {b b' c : R} {a a' : ℤ} (_ : (a : ℤ) = a') (_ : b = b')
(_ : a' • b' = c) :
(a • (b : R)) = c := by
subst_vars; rfl | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | zsmul_congr | null |
pow_congr {b b' : ℕ} (_ : a = a') (_ : b = b')
(_ : a' ^ b' = c) : (a ^ b : R) = c := by subst_vars; rfl | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | pow_congr | null |
neg_congr {R} [Ring R] {a a' b : R} (_ : a = a')
(_ : -a' = b) : (-a : R) = b := by subst_vars; rfl | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | neg_congr | null |
sub_congr {R} [Ring R] {a a' b b' c : R} (_ : a = a') (_ : b = b')
(_ : a' - b' = c) : (a - b : R) = c := by subst_vars; rfl | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | sub_congr | null |
inv_congr {R} [DivisionSemiring R] {a a' b : R} (_ : a = a')
(_ : a'⁻¹ = b) : (a⁻¹ : R) = b := by subst_vars; rfl | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | inv_congr | null |
div_congr {R} [DivisionSemiring R] {a a' b b' c : R} (_ : a = a') (_ : b = b')
(_ : a' / b' = c) : (a / b : R) = c := by subst_vars; rfl | theorem | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | div_congr | null |
Cache.nat : Cache sℕ := { rα := none, dsα := none, czα := some q(inferInstance) } | def | Tactic | [
"Mathlib.Tactic.NormNum.Inv",
"Mathlib.Tactic.NormNum.Pow",
"Mathlib.Util.AtomM"
] | Mathlib/Tactic/Ring/Basic.lean | Cache.nat | A precomputed `Cache` for `ℕ`. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.