mathlib docs: data.int.basic

data.int.basic

int.abs_div_le_abs

int.abs_eq_nat_abs

int.add_comm_monoid

int.add_comm_semigroup

int.add_div_of_dvd

int.add_mod_eq_add_mod_left

int.add_mod_eq_add_mod_right

int.add_mod_mod

int.add_mod_self

int.add_mod_self_left

int.add_mul_div_left

int.add_mul_div_right

int.add_mul_mod_self

int.add_mul_mod_self_left

int.add_one_le_iff

int.add_semigroup

int.bit_cases_on

int.bit_coe_nat

int.bit_neg_succ

int.bitwise_and

int.bitwise_bit

int.bitwise_diff

int.bitwise_xor

int.bodd_add_div2

int.bodd_neg_of_nat

int.bodd_sub_nat_nat

int.coe_nat_abs

int.coe_nat_div

int.coe_nat_dvd

int.coe_nat_dvd_left

int.coe_nat_dvd_right

int.coe_nat_eq_zero

int.coe_nat_inj'

int.coe_nat_mod

int.coe_nat_mul_neg_succ

int.coe_nat_ne_zero

int.coe_nat_ne_zero_iff_pos

int.coe_nat_nonneg

int.coe_nat_pos

int.coe_nat_succ_pos

int.comm_monoid

int.comm_semigroup

int.comm_semiring

int.decidable_dvd

int.decidable_linear_ordered_add_comm_group

int.decidable_linear_ordered_comm_ring

int.default_eq_zero

int.div_dvd_div

int.div_eq_div_of_mul_eq_mul

int.div_eq_iff_eq_mul_left

int.div_eq_iff_eq_mul_right

int.div_eq_of_eq_mul_left

int.div_eq_of_eq_mul_right

int.div_eq_zero_of_lt

int.div_eq_zero_of_lt_abs

int.div_le_of_le_mul

int.div_le_self

int.div_lt_iff_lt_mul

int.div_lt_of_lt_mul

int.div_mul_cancel

int.div_mul_cancel_of_mod_eq_zero

int.div_of_neg_of_pos

int.div_pos_of_pos_of_dvd

int.dvd_antisymm

int.dvd_iff_mod_eq_zero

int.dvd_nat_abs

int.dvd_nat_abs_of_of_nat_dvd

int.dvd_of_mod_eq_zero

int.dvd_of_pow_dvd

int.dvd_sub_of_mod_eq

int.eq_mul_div_of_mul_eq_mul_of_dvd_left

int.eq_mul_of_div_eq_left

int.eq_mul_of_div_eq_right

int.eq_of_mod_eq_of_nat_abs_sub_lt_nat_abs

int.eq_one_of_dvd_one

int.eq_one_of_mul_eq_one_left

int.eq_one_of_mul_eq_one_right

int.eq_zero_of_dvd_of_nat_abs_lt_nat_abs

int.eq_zero_of_dvd_of_nonneg_of_lt

int.exists_greatest_of_bdd

int.exists_least_of_bdd

int.has_reflect

int.has_to_format

int.induction_on

int.induction_on'

int.le_div_iff_mul_le

int.le_div_of_mul_le

int.le_mul_of_div_le

int.le_sub_one_iff

int.lt_add_one_iff

int.lt_div_add_one_mul_self

int.lt_div_iff_mul_lt

int.lt_div_of_mul_lt

int.lt_mul_of_div_lt

int.lt_of_to_nat_lt

int.lt_succ_self

int.mem_to_nat'

int.mod_add_cancel_left

int.mod_add_cancel_right

int.mod_add_div

int.mod_add_div_aux

int.mod_add_mod

int.mod_eq_mod_iff_mod_sub_eq_zero

int.mod_eq_of_lt

int.mod_eq_zero_of_dvd

int.mod_lt_of_pos

int.mod_mod_of_dvd

int.mod_sub_cancel_right

int.mod_two_eq_zero_or_one

int.mul_div_assoc

int.mul_div_cancel

int.mul_div_cancel'

int.mul_div_cancel_left

int.mul_div_cancel_of_mod_eq_zero

int.mul_div_mul_of_pos

int.mul_div_mul_of_pos_left

int.mul_le_of_le_div

int.mul_lt_of_lt_div

int.mul_mod_left

int.mul_mod_mul_of_pos

int.mul_mod_right

int.nat_abs_abs

int.nat_abs_add_le

int.nat_abs_dvd

int.nat_abs_eq_zero

int.nat_abs_lt_nat_abs_of_nonneg_of_lt

int.nat_abs_mul

int.nat_abs_mul_self'

int.nat_abs_ne_zero_of_ne_zero

int.nat_abs_neg_of_nat

int.nat_succ_eq_int_succ

int.neg_add_neg

int.neg_div_of_dvd

int.neg_nat_succ

int.neg_succ_mul_coe_nat

int.neg_succ_mul_neg_succ

int.neg_succ_of_nat_div

int.neg_succ_of_nat_eq'

int.neg_succ_of_nat_mod

int.of_nat_add_neg_succ_of_nat_of_ge

int.of_nat_add_neg_succ_of_nat_of_lt

int.of_nat_dvd_of_dvd_nat_abs

int.pow_dvd_of_le_of_pow_dvd

int.pred_nat_succ

int.pred_neg_pred

int.pred_self_lt

int.shiftl_coe_nat

int.shiftl_eq_mul_pow

int.shiftl_neg_succ

int.shiftr_coe_nat

int.shiftr_eq_div_pow

int.shiftr_neg_succ

int.sign_eq_div_abs

int.sign_mul_abs

int.sub_one_lt_iff

int.succ_neg_nat_succ

int.succ_neg_succ

int.test_bit_bitwise

int.test_bit_land

int.test_bit_ldiff

int.test_bit_lnot

int.test_bit_lor

int.test_bit_lxor

int.test_bit_succ

int.test_bit_zero

int.to_nat_add_one

int.to_nat_coe_nat

int.to_nat_coe_nat_add_one

int.to_nat_eq_max

int.to_nat_le_to_nat

int.to_nat_lt_to_nat

int.to_nat_of_nonneg

int.to_nat_sub_of_le

int.to_nat_zero

int.units_eq_one_or

int.units_inv_eq_self

int.units_nat_abs

int.zero_shiftl

int.zero_shiftr

@[instance]

def int.inhabited :

Equations

int.inhabited = {default := int.zero}

@[instance]

def int.nontrivial :

Equations

int.nontrivial = _

@[instance]

def int.comm_ring :

Equations

int.comm_ring = {add := int.add, add_assoc := int.add_assoc, zero := int.zero, zero_add := int.zero_add, add_zero := int.add_zero, neg := int.neg, add_left_neg := int.add_left_neg, add_comm := int.add_comm, mul := int.mul, mul_assoc := int.mul_assoc, one := int.one, one_mul := int.one_mul, mul_one := int.mul_one, left_distrib := int.distrib_left, right_distrib := int.distrib_right, mul_comm := int.mul_comm}

@[instance]

def int.add_comm_monoid :

add_comm_monoid ℤ

Equations

int.add_comm_monoid = add_comm_group.to_add_comm_monoid ℤ

@[instance]

def int.add_monoid :

Equations

int.add_monoid = add_group.to_add_monoid ℤ

@[instance]

def int.monoid :

Equations

int.monoid = ring.to_monoid ℤ

@[instance]

def int.comm_monoid :

comm_monoid ℤ

Equations

int.comm_monoid = comm_semiring.to_comm_monoid ℤ

@[instance]

def int.comm_semigroup :

comm_semigroup ℤ

Equations

int.comm_semigroup = comm_ring.to_comm_semigroup ℤ

@[instance]

def int.semigroup :

Equations

int.semigroup = monoid.to_semigroup ℤ

@[instance]

def int.add_comm_semigroup :

add_comm_semigroup ℤ

Equations

int.add_comm_semigroup = add_comm_monoid.to_add_comm_semigroup ℤ

@[instance]

def int.add_semigroup :

add_semigroup ℤ

Equations

int.add_semigroup = add_monoid.to_add_semigroup ℤ

@[instance]

def int.comm_semiring :

comm_semiring ℤ

Equations

int.comm_semiring = comm_ring.to_comm_semiring

@[instance]

def int.semiring :

Equations

int.semiring = ring.to_semiring

@[instance]

def int.ring :

Equations

int.ring = comm_ring.to_ring ℤ

@[instance]

def int.distrib :

Equations

int.distrib = ring.to_distrib ℤ

@[instance]

def int.decidable_linear_ordered_comm_ring :

decidable_linear_ordered_comm_ring ℤ

Equations

int.decidable_linear_ordered_comm_ring = {add := comm_ring.add int.comm_ring, add_assoc := _, zero := comm_ring.zero int.comm_ring, zero_add := _, add_zero := _, neg := comm_ring.neg int.comm_ring, add_left_neg := _, add_comm := _, mul := comm_ring.mul int.comm_ring, mul_assoc := _, one := comm_ring.one int.comm_ring, one_mul := _, mul_one := _, left_distrib := _, right_distrib := _, le := decidable_linear_order.le int.decidable_linear_order, lt := decidable_linear_order.lt int.decidable_linear_order, le_refl := _, le_trans := _, lt_iff_le_not_le := _, le_antisymm := _, add_le_add_left := int.add_le_add_left, exists_pair_ne := _, mul_pos := int.mul_pos, le_total := _, zero_lt_one := int.zero_lt_one, mul_comm := _, decidable_le := decidable_linear_order.decidable_le int.decidable_linear_order, decidable_eq := decidable_linear_order.decidable_eq int.decidable_linear_order, decidable_lt := decidable_linear_order.decidable_lt int.decidable_linear_order}

@[instance]

def int.decidable_linear_ordered_add_comm_group :

decidable_linear_ordered_add_comm_group ℤ

Equations

int.decidable_linear_ordered_add_comm_group = decidable_linear_ordered_comm_ring.to_decidable_linear_ordered_add_comm_group ℤ

theorem int.abs_eq_nat_abs (a : ℤ) :

abs a = ↑(a.nat_abs)

theorem int.nat_abs_abs (a : ℤ) :

(abs a).nat_abs = a.nat_abs

theorem int.sign_mul_abs (a : ℤ) :

a.sign * abs a = a

@[simp]

theorem int.default_eq_zero :

inhabited.default ℤ = 0

@[instance]

meta def int.has_to_format :

has_to_format ℤ

@[instance]

meta def int.has_reflect :

has_reflect ℤ

@[simp]

theorem int.add_def {a b : ℤ} :

a.add b = a + b

@[simp]

theorem int.mul_def {a b : ℤ} :

a.mul b = a * b

@[simp]

theorem int.coe_nat_mul_neg_succ (m n : ℕ) :

↑m * -[1+ n] = -(↑m * ↑(n.succ))

@[simp]

theorem int.neg_succ_mul_coe_nat (m n : ℕ) :

-[1+ m] * ↑n = -(↑(m.succ) * ↑n)

@[simp]

theorem int.neg_succ_mul_neg_succ (m n : ℕ) :

-[1+ m] * -[1+ n] = ↑(m.succ) * ↑(n.succ)

@[simp]

theorem int.coe_nat_le {m n : ℕ} :

↑m ≤ ↑n ↔ m ≤ n

@[simp]

theorem int.coe_nat_lt {m n : ℕ} :

↑m < ↑n ↔ m < n

@[simp]

theorem int.coe_nat_inj' {m n : ℕ} :

↑m = ↑n ↔ m = n

@[simp]

theorem int.coe_nat_pos {n : ℕ} :

0 < ↑n ↔ 0 < n

@[simp]

theorem int.coe_nat_eq_zero {n : ℕ} :

↑n = 0 ↔ n = 0

theorem int.coe_nat_ne_zero {n : ℕ} :

↑n ≠ 0 ↔ n ≠ 0

theorem int.coe_nat_nonneg (n : ℕ) :

theorem int.coe_nat_ne_zero_iff_pos {n : ℕ} :

↑n ≠ 0 ↔ 0 < n

theorem int.coe_nat_succ_pos (n : ℕ) :

0 < ↑(n.succ)

@[simp]

theorem int.coe_nat_abs (n : ℕ) :

abs ↑n = ↑n

def int.succ :

Immediate successor of an integer: succ n = n + 1

Equations

a.succ = a + 1

def int.pred :

Immediate predecessor of an integer: pred n = n - 1

Equations

a.pred = a - 1

theorem int.nat_succ_eq_int_succ (n : ℕ) :

↑(n.succ) = ↑n.succ

theorem int.pred_succ (a : ℤ) :

a.succ.pred = a

theorem int.succ_pred (a : ℤ) :

a.pred.succ = a

theorem int.neg_succ (a : ℤ) :

-a.succ = (-a).pred

theorem int.succ_neg_succ (a : ℤ) :

(-a.succ).succ = -a

theorem int.neg_pred (a : ℤ) :

-a.pred = (-a).succ

theorem int.pred_neg_pred (a : ℤ) :

(-a.pred).pred = -a

theorem int.pred_nat_succ (n : ℕ) :

↑(n.succ).pred = ↑n

theorem int.neg_nat_succ (n : ℕ) :

-↑(n.succ) = (-↑n).pred

theorem int.succ_neg_nat_succ (n : ℕ) :

(-↑(n.succ)).succ = -↑n

theorem int.lt_succ_self (a : ℤ) :

a < a.succ

theorem int.pred_self_lt (a : ℤ) :

a.pred < a

theorem int.add_one_le_iff {a b : ℤ} :

a + 1 ≤ b ↔ a < b

theorem int.lt_add_one_iff {a b : ℤ} :

a < b + 1 ↔ a ≤ b

theorem int.le_add_one {a b : ℤ} :

a ≤ b → a ≤ b + 1

theorem int.sub_one_lt_iff {a b : ℤ} :

a - 1 < b ↔ a ≤ b

theorem int.le_sub_one_iff {a b : ℤ} :

a ≤ b - 1 ↔ a < b

theorem int.induction_on {p : ℤ → Prop} (i : ℤ) :

p 0 → (∀ (i : ℕ), p ↑i → p (↑i + 1)) → (∀ (i : ℕ), p (-↑i) → p (-↑i - 1)) → p i

def int.induction_on' {C : ℤ → Sort u_1} (z b : ℤ) :

C b → (Π (k : ℤ), b ≤ k → C k → C (k + 1)) → (Π (k : ℤ), k ≤ b → C k → C (k - 1)) → C z

Equations

z.induction_on' b = λ (H0 : C b) (Hs : Π (k : ℤ), b ≤ k → C k → C (k + 1)) (Hp : Π (k : ℤ), k ≤ b → C k → C (k - 1)), _.mpr (int.rec (λ (a : ℕ), nat.rec (_.mpr (_.mpr H0)) (λ (n : ℕ) (ih : C (int.of_nat n + b)), _.mpr (_.mpr (_.mpr (_.mpr (Hs (int.of_nat n + b) _ ih))))) a) (λ (a : ℕ), nat.rec (_.mpr (_.mpr (_.mpr (_.mpr (_.mpr (Hp b _ H0)))))) (λ (n : ℕ) (ih : C (-[1+ n] + b)), _.mpr (_.mpr (_.mpr (_.mpr (Hp (-[1+ n] + b) _ ih))))) a) (z - b))

theorem int.nat_abs_add_le (a b : ℤ) :

(a + b).nat_abs ≤ a.nat_abs + b.nat_abs

theorem int.nat_abs_neg_of_nat (n : ℕ) :

(int.neg_of_nat n).nat_abs = n

theorem int.nat_abs_mul (a b : ℤ) :

(a * b).nat_abs = a.nat_abs * b.nat_abs

@[simp]

theorem int.nat_abs_mul_self' (a : ℤ) :

↑(a.nat_abs) * ↑(a.nat_abs) = a * a

theorem int.neg_succ_of_nat_eq' (m : ℕ) :

-[1+ m] = -↑m - 1

theorem int.nat_abs_ne_zero_of_ne_zero {z : ℤ} :

z ≠ 0 → z.nat_abs ≠ 0

@[simp]

theorem int.nat_abs_eq_zero {a : ℤ} :

a.nat_abs = 0 ↔ a = 0

theorem int.nat_abs_lt_nat_abs_of_nonneg_of_lt {a b : ℤ} :

0 ≤ a → a < b → a.nat_abs < b.nat_abs

@[simp]

theorem int.of_nat_div (m n : ℕ) :

int.of_nat (m / n) = int.of_nat m / int.of_nat n

@[simp]

theorem int.coe_nat_div (m n : ℕ) :

↑(m / n) = ↑m / ↑n

theorem int.neg_succ_of_nat_div (m : ℕ) {b : ℤ} :

0 < b → -[1+ m] / b = -(↑m / b + 1)

@[simp]

theorem int.div_neg (a b : ℤ) :

a / -b = -(a / b)

theorem int.div_of_neg_of_pos {a b : ℤ} :

a < 0 → 0 < b → a / b = -((-a - 1) / b + 1)

theorem int.div_nonneg {a b : ℤ} :

0 ≤ a → 0 ≤ b → 0 ≤ a / b

theorem int.div_nonpos {a b : ℤ} :

0 ≤ a → b ≤ 0 → a / b ≤ 0

theorem int.div_neg' {a b : ℤ} :

a < 0 → 0 < b → a / b < 0

theorem int.zero_div (b : ℤ) :

0 / b = 0

theorem int.div_zero (a : ℤ) :

a / 0 = 0

@[simp]

theorem int.div_one (a : ℤ) :

a / 1 = a

theorem int.div_eq_zero_of_lt {a b : ℤ} :

0 ≤ a → a < b → a / b = 0

theorem int.div_eq_zero_of_lt_abs {a b : ℤ} :

0 ≤ a → a < abs b → a / b = 0

theorem int.add_mul_div_right (a b : ℤ) {c : ℤ} :

c ≠ 0 → (a + b * c) / c = a / c + b

theorem int.add_mul_div_left (a : ℤ) {b : ℤ} (c : ℤ) :

b ≠ 0 → (a + b * c) / b = a / b + c

@[simp]

theorem int.mul_div_cancel (a : ℤ) {b : ℤ} :

b ≠ 0 → a * b / b = a

@[simp]

theorem int.mul_div_cancel_left {a : ℤ} (b : ℤ) :

a ≠ 0 → a * b / a = b

@[simp]

theorem int.div_self {a : ℤ} :

a ≠ 0 → a / a = 1

theorem int.of_nat_mod (m n : ℕ) :

↑m % ↑n = int.of_nat (m % n)

@[simp]

theorem int.coe_nat_mod (m n : ℕ) :

↑(m % n) = ↑m % ↑n

theorem int.neg_succ_of_nat_mod (m : ℕ) {b : ℤ} :

0 < b → -[1+ m] % b = b - 1 - ↑m % b

@[simp]

theorem int.mod_neg (a b : ℤ) :

a % -b = a % b

@[simp]

theorem int.mod_abs (a b : ℤ) :

a % abs b = a % b

theorem int.zero_mod (b : ℤ) :

0 % b = 0

theorem int.mod_zero (a : ℤ) :

a % 0 = a

theorem int.mod_one (a : ℤ) :

a % 1 = 0

theorem int.mod_eq_of_lt {a b : ℤ} :

0 ≤ a → a < b → a % b = a

theorem int.mod_nonneg (a : ℤ) {b : ℤ} :

b ≠ 0 → 0 ≤ a % b

theorem int.mod_lt_of_pos (a : ℤ) {b : ℤ} :

0 < b → a % b < b

theorem int.mod_lt (a : ℤ) {b : ℤ} :

b ≠ 0 → a % b < abs b

theorem int.mod_add_div_aux (m n : ℕ) :

↑n - (↑m % ↑n + 1) - (↑n * (↑m / ↑n) + ↑n) = -[1+ m]

theorem int.mod_add_div (a b : ℤ) :

a % b + b * (a / b) = a

theorem int.mod_def (a b : ℤ) :

a % b = a - b * (a / b)

@[simp]

theorem int.add_mul_mod_self {a b c : ℤ} :

(a + b * c) % c = a % c

@[simp]

theorem int.add_mul_mod_self_left (a b c : ℤ) :

(a + b * c) % b = a % b

@[simp]

theorem int.add_mod_self {a b : ℤ} :

(a + b) % b = a % b

@[simp]

theorem int.add_mod_self_left {a b : ℤ} :

(a + b) % a = b % a

@[simp]

theorem int.mod_add_mod (m n k : ℤ) :

(m % n + k) % n = (m + k) % n

@[simp]

theorem int.add_mod_mod (m n k : ℤ) :

(m + n % k) % k = (m + n) % k

theorem int.add_mod (a b n : ℤ) :

(a + b) % n = (a % n + b % n) % n

theorem int.add_mod_eq_add_mod_right {m n k : ℤ} (i : ℤ) :

m % n = k % n → (m + i) % n = (k + i) % n

theorem int.add_mod_eq_add_mod_left {m n k : ℤ} (i : ℤ) :

m % n = k % n → (i + m) % n = (i + k) % n

theorem int.mod_add_cancel_right {m n k : ℤ} (i : ℤ) :

(m + i) % n = (k + i) % n ↔ m % n = k % n

theorem int.mod_add_cancel_left {m n k i : ℤ} :

(i + m) % n = (i + k) % n ↔ m % n = k % n

theorem int.mod_sub_cancel_right {m n k : ℤ} (i : ℤ) :

(m - i) % n = (k - i) % n ↔ m % n = k % n

theorem int.mod_eq_mod_iff_mod_sub_eq_zero {m n k : ℤ} :

m % n = k % n ↔ (m - k) % n = 0

@[simp]

theorem int.mul_mod_left (a b : ℤ) :

a * b % b = 0

@[simp]

theorem int.mul_mod_right (a b : ℤ) :

a * b % a = 0

theorem int.mul_mod (a b n : ℤ) :

a * b % n = a % n * (b % n) % n

theorem int.mod_self {a : ℤ} :

a % a = 0

@[simp]

theorem int.mod_mod_of_dvd (n : ℤ) {m k : ℤ} :

m ∣ k → n % k % m = n % m

@[simp]

theorem int.mod_mod (a b : ℤ) :

a % b % b = a % b

theorem int.sub_mod (a b n : ℤ) :

(a - b) % n = (a % n - b % n) % n

@[simp]

theorem int.mul_div_mul_of_pos {a : ℤ} (b c : ℤ) :

0 < a → a * b / (a * c) = b / c

@[simp]

theorem int.mul_div_mul_of_pos_left (a : ℤ) {b : ℤ} (c : ℤ) :

0 < b → a * b / (c * b) = a / c

@[simp]

theorem int.mul_mod_mul_of_pos {a : ℤ} (b c : ℤ) :

0 < a → a * b % (a * c) = a * (b % c)

theorem int.lt_div_add_one_mul_self (a : ℤ) {b : ℤ} :

0 < b → a < (a / b + 1) * b

theorem int.abs_div_le_abs (a b : ℤ) :

abs (a / b) ≤ abs a

theorem int.div_le_self {a : ℤ} (b : ℤ) :

0 ≤ a → a / b ≤ a

theorem int.mul_div_cancel_of_mod_eq_zero {a b : ℤ} :

a % b = 0 → b * (a / b) = a

theorem int.div_mul_cancel_of_mod_eq_zero {a b : ℤ} :

a % b = 0 → a / b * b = a

theorem int.mod_two_eq_zero_or_one (n : ℤ) :

n % 2 = 0 ∨ n % 2 = 1

theorem int.coe_nat_dvd {m n : ℕ} :

↑m ∣ ↑n ↔ m ∣ n

theorem int.coe_nat_dvd_left {n : ℕ} {z : ℤ} :

↑n ∣ z ↔ n ∣ z.nat_abs

theorem int.coe_nat_dvd_right {n : ℕ} {z : ℤ} :

z ∣ ↑n ↔ z.nat_abs ∣ n

theorem int.dvd_antisymm {a b : ℤ} :

0 ≤ a → 0 ≤ b → a ∣ b → b ∣ a → a = b

theorem int.dvd_of_mod_eq_zero {a b : ℤ} :

b % a = 0 → a ∣ b

theorem int.mod_eq_zero_of_dvd {a b : ℤ} :

a ∣ b → b % a = 0

theorem int.dvd_iff_mod_eq_zero (a b : ℤ) :

a ∣ b ↔ b % a = 0

theorem int.dvd_sub_of_mod_eq {a b c : ℤ} :

a % b = c → b ∣ a - c

If a % b = c then b divides a - c.

theorem int.nat_abs_dvd {a b : ℤ} :

↑(a.nat_abs) ∣ b ↔ a ∣ b

theorem int.dvd_nat_abs {a b : ℤ} :

a ∣ ↑(b.nat_abs) ↔ a ∣ b

@[instance]

def int.decidable_dvd :

decidable_rel has_dvd.dvd

Equations

int.decidable_dvd = λ (a n : ℤ), decidable_of_decidable_of_iff (int.decidable_eq (n % a) 0) _

theorem int.div_mul_cancel {a b : ℤ} :

b ∣ a → a / b * b = a

theorem int.mul_div_cancel' {a b : ℤ} :

a ∣ b → a * (b / a) = b

theorem int.mul_div_assoc (a : ℤ) {b c : ℤ} :

c ∣ b → a * b / c = a * (b / c)

theorem int.div_dvd_div {a b c : ℤ} :

a ∣ b → b ∣ c → b / a ∣ c / a

theorem int.eq_mul_of_div_eq_right {a b c : ℤ} :

b ∣ a → a / b = c → a = b * c

theorem int.div_eq_of_eq_mul_right {a b c : ℤ} :

b ≠ 0 → a = b * c → a / b = c

theorem int.div_eq_iff_eq_mul_right {a b c : ℤ} :

b ≠ 0 → b ∣ a → (a / b = c ↔ a = b * c)

theorem int.div_eq_iff_eq_mul_left {a b c : ℤ} :

b ≠ 0 → b ∣ a → (a / b = c ↔ a = c * b)

theorem int.eq_mul_of_div_eq_left {a b c : ℤ} :

b ∣ a → a / b = c → a = c * b

theorem int.div_eq_of_eq_mul_left {a b c : ℤ} :

b ≠ 0 → a = c * b → a / b = c

theorem int.neg_div_of_dvd {a b : ℤ} :

b ∣ a → -a / b = -(a / b)

theorem int.add_div_of_dvd {a b c : ℤ} :

c ∣ a → c ∣ b → (a + b) / c = a / c + b / c

theorem int.div_sign (a b : ℤ) :

a / b.sign = a * b.sign

@[simp]

theorem int.sign_mul (a b : ℤ) :

(a * b).sign = a.sign * b.sign

theorem int.sign_eq_div_abs (a : ℤ) :

a.sign = a / abs a

theorem int.mul_sign (i : ℤ) :

i * i.sign = ↑(i.nat_abs)

theorem int.le_of_dvd {a b : ℤ} :

0 < b → a ∣ b → a ≤ b

theorem int.eq_one_of_dvd_one {a : ℤ} :

0 ≤ a → a ∣ 1 → a = 1

theorem int.eq_one_of_mul_eq_one_right {a b : ℤ} :

0 ≤ a → a * b = 1 → a = 1

theorem int.eq_one_of_mul_eq_one_left {a b : ℤ} :

0 ≤ b → a * b = 1 → b = 1

theorem int.of_nat_dvd_of_dvd_nat_abs {a : ℕ} {z : ℤ} :

a ∣ z.nat_abs → ↑a ∣ z

theorem int.dvd_nat_abs_of_of_nat_dvd {a : ℕ} {z : ℤ} :

↑a ∣ z → a ∣ z.nat_abs

theorem int.pow_dvd_of_le_of_pow_dvd {p m n : ℕ} {k : ℤ} :

m ≤ n → ↑(p ^ n) ∣ k → ↑(p ^ m) ∣ k

theorem int.dvd_of_pow_dvd {p k : ℕ} {m : ℤ} :

1 ≤ k → ↑(p ^ k) ∣ m → ↑p ∣ m

theorem int.div_mul_le (a : ℤ) {b : ℤ} :

b ≠ 0 → a / b * b ≤ a

theorem int.div_le_of_le_mul {a b c : ℤ} :

0 < c → a ≤ b * c → a / c ≤ b

theorem int.mul_lt_of_lt_div {a b c : ℤ} :

0 < c → a < b / c → a * c < b

theorem int.mul_le_of_le_div {a b c : ℤ} :

0 < c → a ≤ b / c → a * c ≤ b

theorem int.le_div_of_mul_le {a b c : ℤ} :

0 < c → a * c ≤ b → a ≤ b / c

theorem int.le_div_iff_mul_le {a b c : ℤ} :

0 < c → (a ≤ b / c ↔ a * c ≤ b)

theorem int.div_le_div {a b c : ℤ} :

0 < c → a ≤ b → a / c ≤ b / c

theorem int.div_lt_of_lt_mul {a b c : ℤ} :

0 < c → a < b * c → a / c < b

theorem int.lt_mul_of_div_lt {a b c : ℤ} :

0 < c → a / c < b → a < b * c

theorem int.div_lt_iff_lt_mul {a b c : ℤ} :

0 < c → (a / c < b ↔ a < b * c)

theorem int.le_mul_of_div_le {a b c : ℤ} :

0 ≤ b → b ∣ a → a / b ≤ c → a ≤ c * b

theorem int.lt_div_of_mul_lt {a b c : ℤ} :

0 ≤ b → b ∣ c → a * b < c → a < c / b

theorem int.lt_div_iff_mul_lt {a b : ℤ} (c : ℤ) :

0 < c → c ∣ b → (a < b / c ↔ a * c < b)

theorem int.div_pos_of_pos_of_dvd {a b : ℤ} :

0 < a → 0 ≤ b → b ∣ a → 0 < a / b

theorem int.div_eq_div_of_mul_eq_mul {a b c d : ℤ} :

d ∣ c → b ≠ 0 → d ≠ 0 → a * d = b * c → a / b = c / d

theorem int.eq_mul_div_of_mul_eq_mul_of_dvd_left {a b c d : ℤ} :

b ≠ 0 → b ∣ c → b * a = c * d → a = c / b * d

theorem int.eq_zero_of_dvd_of_nat_abs_lt_nat_abs {a b : ℤ} :

a ∣ b → b.nat_abs < a.nat_abs → b = 0

If an integer with larger absolute value divides an integer, it is zero.

theorem int.eq_zero_of_dvd_of_nonneg_of_lt {a b : ℤ} :

0 ≤ a → a < b → b ∣ a → a = 0

theorem int.eq_of_mod_eq_of_nat_abs_sub_lt_nat_abs {a b c : ℤ} :

a % b = c → (a - c).nat_abs < b.nat_abs → a = c

If two integers are congruent to a sufficiently large modulus, they are equal.

theorem int.of_nat_add_neg_succ_of_nat_of_lt {m n : ℕ} :

m < n.succ → int.of_nat m + -[1+ n] = -[1+ n - m]

theorem int.of_nat_add_neg_succ_of_nat_of_ge {m n : ℕ} :

n.succ ≤ m → int.of_nat m + -[1+ n] = int.of_nat (m - n.succ)

@[simp]

theorem int.neg_add_neg (m n : ℕ) :

-[1+ m] + -[1+ n] = -[1+ (m + n).succ]

theorem int.to_nat_eq_max (a : ℤ) :

↑(a.to_nat) = max a 0

@[simp]

theorem int.to_nat_zero :

@[simp]

theorem int.to_nat_one :

@[simp]

theorem int.to_nat_of_nonneg {a : ℤ} :

0 ≤ a → ↑(a.to_nat) = a

@[simp]

theorem int.to_nat_sub_of_le (a b : ℤ) :

b ≤ a → ↑((a + -b).to_nat) = a + -b

@[simp]

theorem int.to_nat_coe_nat (n : ℕ) :

↑n.to_nat = n

@[simp]

theorem int.to_nat_coe_nat_add_one {n : ℕ} :

(↑n + 1).to_nat = n + 1

theorem int.le_to_nat (a : ℤ) :

a ≤ ↑(a.to_nat)

@[simp]

theorem int.to_nat_le {a : ℤ} {n : ℕ} :

a.to_nat ≤ n ↔ a ≤ ↑n

@[simp]

theorem int.lt_to_nat {n : ℕ} {a : ℤ} :

n < a.to_nat ↔ ↑n < a

theorem int.to_nat_le_to_nat {a b : ℤ} :

a ≤ b → a.to_nat ≤ b.to_nat

theorem int.to_nat_lt_to_nat {a b : ℤ} :

0 < b → (a.to_nat < b.to_nat ↔ a < b)

theorem int.lt_of_to_nat_lt {a b : ℤ} :

a.to_nat < b.to_nat → a < b

theorem int.to_nat_add {a b : ℤ} :

0 ≤ a → 0 ≤ b → (a + b).to_nat = a.to_nat + b.to_nat

theorem int.to_nat_add_one {a : ℤ} :

0 ≤ a → (a + 1).to_nat = a.to_nat + 1

def int.to_nat' :

ℤ → option ℕ

Equations

-[1+ n].to_nat' = option.none
↑n.to_nat' = option.some n

theorem int.mem_to_nat' (a : ℤ) (n : ℕ) :

n ∈ a.to_nat' ↔ a = ↑n

@[simp]

theorem int.units_nat_abs (u : units ℤ) :

↑u.nat_abs = 1

theorem int.units_eq_one_or (u : units ℤ) :

u = 1 ∨ u = -1

theorem int.units_inv_eq_self (u : units ℤ) :

@[simp]

theorem int.bodd_zero :

0.bodd = bool.ff

@[simp]

theorem int.bodd_one :

1.bodd = bool.tt

@[simp]

theorem int.bodd_two :

2.bodd = bool.ff

@[simp]

theorem int.bodd_coe (n : ℕ) :

↑n.bodd = n.bodd

@[simp]

theorem int.bodd_sub_nat_nat (m n : ℕ) :

(int.sub_nat_nat m n).bodd = bxor m.bodd n.bodd

@[simp]

theorem int.bodd_neg_of_nat (n : ℕ) :

(int.neg_of_nat n).bodd = n.bodd

@[simp]

theorem int.bodd_neg (n : ℤ) :

(-n).bodd = n.bodd

@[simp]

theorem int.bodd_add (m n : ℤ) :

(m + n).bodd = bxor m.bodd n.bodd

@[simp]

theorem int.bodd_mul (m n : ℤ) :

(m * n).bodd = m.bodd && n.bodd

theorem int.bodd_add_div2 (n : ℤ) :

cond n.bodd 1 0 + 2 * n.div2 = n

theorem int.div2_val (n : ℤ) :

n.div2 = n / 2

theorem int.bit0_val (n : ℤ) :

bit0 n = 2 * n

theorem int.bit1_val (n : ℤ) :

bit1 n = 2 * n + 1

theorem int.bit_val (b : bool) (n : ℤ) :

int.bit b n = 2 * n + cond b 1 0

theorem int.bit_decomp (n : ℤ) :

int.bit n.bodd n.div2 = n

def int.bit_cases_on {C : ℤ → Sort u} (n : ℤ) :

(Π (b : bool) (n : ℤ), C (int.bit b n)) → C n

Equations

n.bit_cases_on h = _.mpr (h n.bodd n.div2)

@[simp]

theorem int.bit_zero :

int.bit bool.ff 0 = 0

@[simp]

theorem int.bit_coe_nat (b : bool) (n : ℕ) :

int.bit b ↑n = ↑(nat.bit b n)

@[simp]

theorem int.bit_neg_succ (b : bool) (n : ℕ) :

int.bit b -[1+ n] = -[1+ nat.bit (!b) n]

@[simp]

theorem int.bodd_bit (b : bool) (n : ℤ) :

(int.bit b n).bodd = b

@[simp]

theorem int.div2_bit (b : bool) (n : ℤ) :

(int.bit b n).div2 = n

@[simp]

theorem int.test_bit_zero (b : bool) (n : ℤ) :

(int.bit b n).test_bit 0 = b

@[simp]

theorem int.test_bit_succ (m : ℕ) (b : bool) (n : ℤ) :

(int.bit b n).test_bit m.succ = n.test_bit m

theorem int.bitwise_or :

int.bitwise bor = int.lor

theorem int.bitwise_and :

int.bitwise band = int.land

theorem int.bitwise_diff :

int.bitwise (λ (a b : bool), a && !b) = int.ldiff

theorem int.bitwise_xor :

int.bitwise bxor = int.lxor

@[simp]

theorem int.bitwise_bit (f : bool → bool → bool) (a : bool) (m : ℤ) (b : bool) (n : ℤ) :

int.bitwise f (int.bit a m) (int.bit b n) = int.bit (f a b) (int.bitwise f m n)

@[simp]

theorem int.lor_bit (a : bool) (m : ℤ) (b : bool) (n : ℤ) :

(int.bit a m).lor (int.bit b n) = int.bit (a || b) (m.lor n)

@[simp]

theorem int.land_bit (a : bool) (m : ℤ) (b : bool) (n : ℤ) :

(int.bit a m).land (int.bit b n) = int.bit (a && b) (m.land n)

@[simp]

theorem int.ldiff_bit (a : bool) (m : ℤ) (b : bool) (n : ℤ) :

(int.bit a m).ldiff (int.bit b n) = int.bit (a && !b) (m.ldiff n)

@[simp]

theorem int.lxor_bit (a : bool) (m : ℤ) (b : bool) (n : ℤ) :

(int.bit a m).lxor (int.bit b n) = int.bit (bxor a b) (m.lxor n)

@[simp]

theorem int.lnot_bit (b : bool) (n : ℤ) :

(int.bit b n).lnot = int.bit (!b) n.lnot

@[simp]

theorem int.test_bit_bitwise (f : bool → bool → bool) (m n : ℤ) (k : ℕ) :

(int.bitwise f m n).test_bit k = f (m.test_bit k) (n.test_bit k)

@[simp]

theorem int.test_bit_lor (m n : ℤ) (k : ℕ) :

(m.lor n).test_bit k = m.test_bit k || n.test_bit k

@[simp]

theorem int.test_bit_land (m n : ℤ) (k : ℕ) :

(m.land n).test_bit k = m.test_bit k && n.test_bit k

@[simp]

theorem int.test_bit_ldiff (m n : ℤ) (k : ℕ) :

(m.ldiff n).test_bit k = m.test_bit k && !n.test_bit k

@[simp]

theorem int.test_bit_lxor (m n : ℤ) (k : ℕ) :

(m.lxor n).test_bit k = bxor (m.test_bit k) (n.test_bit k)

@[simp]

theorem int.test_bit_lnot (n : ℤ) (k : ℕ) :

n.lnot.test_bit k = !n.test_bit k

theorem int.shiftl_add (m : ℤ) (n : ℕ) (k : ℤ) :

m.shiftl (↑n + k) = (m.shiftl ↑n).shiftl k

theorem int.shiftl_sub (m : ℤ) (n : ℕ) (k : ℤ) :

m.shiftl (↑n - k) = (m.shiftl ↑n).shiftr k

@[simp]

theorem int.shiftl_neg (m n : ℤ) :

m.shiftl (-n) = m.shiftr n

@[simp]

theorem int.shiftr_neg (m n : ℤ) :

m.shiftr (-n) = m.shiftl n

@[simp]

theorem int.shiftl_coe_nat (m n : ℕ) :

↑m.shiftl ↑n = ↑(m.shiftl n)

@[simp]

theorem int.shiftr_coe_nat (m n : ℕ) :

↑m.shiftr ↑n = ↑(m.shiftr n)

@[simp]

theorem int.shiftl_neg_succ (m n : ℕ) :

-[1+ m].shiftl ↑n = -[1+ nat.shiftl' bool.tt m n]

@[simp]

theorem int.shiftr_neg_succ (m n : ℕ) :

-[1+ m].shiftr ↑n = -[1+ m.shiftr n]

theorem int.shiftr_add (m : ℤ) (n k : ℕ) :

m.shiftr (↑n + ↑k) = (m.shiftr ↑n).shiftr ↑k

theorem int.shiftl_eq_mul_pow (m : ℤ) (n : ℕ) :

m.shiftl ↑n = m * ↑(2 ^ n)

theorem int.shiftr_eq_div_pow (m : ℤ) (n : ℕ) :

m.shiftr ↑n = m / ↑(2 ^ n)

theorem int.one_shiftl (n : ℕ) :

1.shiftl ↑n = ↑(2 ^ n)

@[simp]

theorem int.zero_shiftl (n : ℤ) :

0.shiftl n = 0

@[simp]

theorem int.zero_shiftr (n : ℤ) :

0.shiftr n = 0

theorem int.exists_least_of_bdd {P : ℤ → Prop} :

(∃ (b : ℤ), ∀ (z : ℤ), P z → b ≤ z) → (∃ (z : ℤ), P z) → (∃ (lb : ℤ), P lb ∧ ∀ (z : ℤ), P z → lb ≤ z)

theorem int.exists_greatest_of_bdd {P : ℤ → Prop} :

(∃ (b : ℤ), ∀ (z : ℤ), P z → z ≤ b) → (∃ (z : ℤ), P z) → (∃ (ub : ℤ), P ub ∧ ∀ (z : ℤ), P z → z ≤ ub)

General documentation

Additional documentation

mathlib overview

well founded recursion

documentation style guide

naming conventions

Library

algebra

big_operators

basic

intervals

order

pi

ring

category

Algebra

basic

limits

CommRing

adjunctions

basic

colimits

limits

Group

Z_Module_equivalence

abelian

adjunctions

basic

biproducts

colimits

images

limits

preadditive

zero

Module

abelian

basic

kernels

limits

monoidal

Mon

basic

colimits

limits

continued_fractions

computation

approximations

basic

correctness_terminating

translations

basic

continuants_recurrence

convergents_equiv

terminated_stable

translations

group

basic

commute

conj

defs

hom

inj_surj

pi

prod

semiconj

to_additive

type_tags

ulift

units

units_hom

with_one

homology

chain_complex

exact

homology

image_to_kernel_map

module

basic

ordered

pi

prod

submodule

ulift

polynomial

big_operators

ring

basic

pi

prod

ulift

add_torsor

archimedean

associated

char_p

char_zero

classical_lie_algebras

direct_limit

direct_sum

divisibility

euclidean_domain

field

field_power

floor

free

free_monoid

gcd_monoid

geom_sum

group_action_hom

group_power

group_ring_action

group_with_zero

group_with_zero_power

invertible

iterate_hom

lie_algebra

linear_ordered_comm_group_with_zero

linear_recurrence

midpoint

opposites

order

order_functions

ordered_field

ordered_group

ordered_ring

pointwise

punit_instances

quadratic_discriminant

algebraic_geometry

presheafed_space

prime_spectrum

stalks

analysis

ODE

gronwall

analytic

basic

composition

calculus

darboux

deriv

extend_deriv

fderiv

implicit

inverse

iterated_deriv

lhopital

local_extr

mean_value

specific_functions

tangent_cone

times_cont_diff

complex

basic

polynomial

convex

basic

caratheodory

cone

extrema

specific_functions

topology

normed_space

add_torsor

banach

basic

bounded_linear_maps

complemented

dual

enorm

extend

finite_dimension

hahn_banach

indicator_function

mazur_ulam

multilinear

operator_norm

point_reflection

real_inner_product

riesz_lemma

units

special_functions

arsinh

exp_log

pow

trigonometric

asymptotics

hofer

mean_inequalities

specific_limits

category_theory

abelian

diagram_lemmas

four

basic

exact

non_preadditive

pseudoelements

adjunction

basic

fully_faithful

limits

opposites

category

Cat

Groupoid

Kleisli

Rel

default

closed

cartesian

monoidal

concrete_category

basic

bundled

bundled_hom

reflects_isomorphisms

unbundled_hom

limits

preserves

basic

shapes

shapes

constructions

over

connected

default

products

binary_products

equalizers

limits_of_products_and_equalizers

preserve_binary_products

pullbacks

binary_products

biproducts

concrete_category

equalizers

finite_limits

finite_products

images

kernels

products

pullbacks

regular_mono

strong_epi

terminal

types

wide_pullbacks

zero

concrete_category

cones

connected

creates

fubini

functor_category

lattice

limits

opposites

over

pi

punit

types

monad

adjunction

algebra

basic

bundled

equiv_mon

limits

types

monoidal

internal

functor_category

types

End

braided

category

functor

functor_category

functorial

internal

of_has_finite_products

types

unitors

pi

basic

preadditive

biproducts

default

schur

products

associator

basic

bifunctor

sums

associator

basic

action

arrow

comma

conj

connected

const

core

currying

differential_object

discrete_category

elements

endomorphism

epi_mono

eq_to_hom

equivalence

full_subcategory

fully_faithful

functor

functor_category

functorial

graded_object

groupoid

hom_functor

isomorphism

isomorphism_classes

natural_isomorphism

natural_transformation

opposites

over

pempty

punit

quotient

reflects_isomorphisms

shift

simple

single_obj

sparse

types

whiskering

yoneda

combinatorics

composition

simple_graph

computability

halting

partrec

partrec_code

primrec

reduce

tm_to_partrec

turing_machine

control

bitraversable

basic

instances

lemmas

equiv_functor

instances

functor

multivariate

monad

basic

cont

writer

traversable

basic

derive

equiv

instances

lemmas

applicative

basic

bifunctor

equiv_functor

fold

functor

uliftable

core

data

buffer

parser

bitvec

buffer

dlist

lazy_list

stream

vector

init

algebra

classes

functions

order

control

alternative

applicative

combinators

except

functor

id

lawful

lift

monad

monad_fail

option

reader

state

data

array

basic

slice

bool

basic

lemmas

char

basic

classes

lemmas

fin

basic

ops

int

basic

bitwise

comp_lemmas

order

list

basic

instances

lemmas

qsort

nat

basic

bitwise

div

gcd

lemmas

option

basic

instances

ordering

basic

lemmas

rbmap

basic

rbtree

basic

default

sigma

basic

lex

string

basic

ops

subtype

basic

instances

sum

basic

unsigned

basic

ops

prod

punit

quot

repr

set

setoid

to_string

meta

converter

conv

interactive

lean

parser

smt

congruence_closure

ematch

interactive

rsimp

smt_tactic

widget

basic

html_cmd

interactive_expr

replace_save_info

tactic_component

ac_tactics

async_tactic

attribute

backward

case_tag

comp_value_tactics

congr_lemma

congr_tactic

constructor_tactic

contradiction_tactic

declaration

derive

environment

exceptional

expr

expr_address

float

format

fun_info

has_reflect

hole_command

injection_tactic

interaction_monad

interactive

interactive_base

level

local_context

match_tactic

mk_dec_eq_instance

mk_has_reflect_instance

mk_has_sizeof_instance

mk_inhabited_instance

module_info

name

occurrences

options

pexpr

rb_map

rec_util

ref

relation_tactics

rewrite_tactic

set_get_option_tactics

simp_tactic

tactic

tagged_format

task

type_context

vm

well_founded_tactics

cc_lemmas

classical

coe

core

default

function

funext

ite_simp

logic

propext

util

version

wf

system

io

io_interface

random

data

analysis

filter

topology

array

lemmas

bitvec

basic

buffer

basic

complex

basic

exponential

module

dlist

basic

instances

equiv

encodable

basic

lattice

basic

denumerable

fin

functor

list

local_equiv

mul_add

nat

ring

transfer_instance

finset

basic

fold

intervals

lattice

nat_antidiagonal

order

pi

powerset

sort

finsupp

basic

lattice

pointwise

fintype

basic

card

intervals

sort

fp

basic

int

basic

cast

char_zero

gcd

modeq

parity

range

sqrt

list

alist

bag_inter

basic

chain

defs

erase_dup

forall2

func

indexes

intervals

min_max

nat_antidiagonal

nodup

of_fn

pairwise

palindrome

perm

range

rotate

sections

sigma

sort

tfae

zip

matrix

basic

notation

pequiv

multiset

antidiagonal

basic

erase_dup

finset_ops

fold

functor

intervals

lattice

nat_antidiagonal

nodup

pi

powerset

range

sections

sort

nat

basic

cast

choose

digits

dist

enat

fib

gcd

modeq

multiplicity

pairing

parity

prime

sqrt

totient

num

basic

bitwise

lemmas

prime

option

basic

defs

padics

hensel

padic_integers

padic_norm

padic_numbers

pfunctor

multivariate

M

W

basic

univariate

M

basic

pnat

basic

factors

intervals

xgcd

polynomial

degree

basic

algebra_map

basic

coeff

degree

derivative

div

eval

field_division

identities

induction

integral_normalization

monic

monomial

ring_division

qpf

multivariate

constructions

cofix

comp

const

fix

prj

quot

sigma

basic

univariate

basic

rat

basic

cast

denumerable

floor

meta_defs

order

sqrt

real

basic

cardinality

cau_seq

cau_seq_completion

conjugate_exponents

ennreal

ereal

golden_ratio

hyperreal

irrational

nnreal

pi

seq

computation

parallel

seq

wseq

set

intervals

basic

disjoint

image_preimage

ord_connected

unordered_interval

basic

countable

disjointed

enumerate

finite

function

lattice

setoid

basic

partition

sigma

basic

stream

basic

string

basic

defs

zmod

basic

zsqrtd

basic

gaussian_int

W

bool

char

dfinsupp

erased

fin

fin2

fin_enum

finmap

hash_map

holor

indicator_function

lazy_list2

mllist

monoid_algebra

mv_polynomial

opposite

pequiv

pfun

prod

quot

rel

semiquot

subtype

sum

support

sym

sym2

tree

typevec

ulift

vector2

deprecated

group

ring

subgroup

submonoid

dynamics

circle

rotation_number

translation_number

fixed_points

basic

topology

periodic_pts

field_theory

algebraic_closure

chevalley_warning

finite

fixed

minimal_polynomial

mv_polynomial

normal

perfect_closure

separable

splitting_field

subfield

tower

geometry

algebra

lie_group

euclidean

basic

circumcenter

monge_point

triangle

manifold

basic_smooth_bundle

charted_space

local_invariant_properties

mfderiv

real_instances

smooth_manifold_with_corners

times_cont_mdiff

group_theory

perm

cycles

sign

submonoid

basic

membership

operations

abelianization

congruence

coset

eckmann_hilton

free_abelian_group

free_group

group_action

monoid_localization

order_of_element

presented_group

quotient_group

semidirect_product

subgroup

sylow

linear_algebra

affine_space

basic

combination

finite_dimensional

independent

char_poly

coeff

direct_sum

finsupp

tensor_product

adic_completion

basic

basis

bilinear_form

char_poly

contraction

determinant

dimension

direct_sum_module

dual

finite_dimensional

finsupp

finsupp_vector_space

invariant_basis_number

lagrange

linear_action

linear_pmap

matrix

multilinear

nonsingular_inverse

projection

quadratic_form

sesquilinear_form

smodeq

special_linear_group

tensor_algebra

tensor_product

logic

function

basic

conjugate

iterate

basic

embedding

nontrivial

relation

relator

unique

measure_theory

category

Meas

ae_eq_fun

bochner_integration

borel_space

content

decomposition

giry_monad

group

haar_measure

integration

interval_integral

l1_space

lebesgue_measure

measurable_space

measure_space

outer_measure

probability_mass_function

set_integral

simple_func_dense

meta

coinductive_predicates

expr

expr_lens

rb_map

uchange

number_theory

basic

bernoulli

dioph

lucas_lehmer

pell

primorial

pythagorean_triples

quadratic_reciprocity

sum_four_squares

sum_two_squares

order

category

LinearOrder

NonemptyFinLinOrd

PartialOrder

Preorder

filter

at_top_bot

bases

basic

cofinite

countable_Inter

extr

filter_product

germ

indicator_function

interval

lift

partial

pointwise

ultrafilter

basic

boolean_algebra

bounded_lattice

bounds

complete_boolean_algebra

complete_lattice

conditionally_complete_lattice

copy

directed

fixed_points

galois_connection

ideal

iterate

lattice

lexicographic

liminf_limsup

ord_continuous

order_iso_nat

pilex

rel_classes

rel_iso

semiconj_Sup

zorn

representation_theory

maschke

ring_theory

ideal

basic

operations

over

polynomial

basic

homogeneous

rational_root

valuation

basic

adjoin

adjoin_root

algebra

algebra_operations

algebra_tower

algebraic

coprime

derivation

discrete_valuation_ring

eisenstein_criterion

euclidean_domain

fintype

fractional_ideal

free_comm_ring

free_ring

integral_closure

integral_domain

jacobson

jacobson_ideal

localization

maps

matrix_algebra

multiplicity

noetherian

polynomial_algebra

power_series

prime

principal_ideal_domain

subring

subsemiring

tensor_product

unique_factorization_domain

set_theory

game

domineering

impartial

nim

short

state

winner

cardinal

cardinal_ordinal

cofinality

game

lists

ordinal

ordinal_arithmetic

ordinal_notation

pgame

schroeder_bernstein

surreal

zfc

system

random

basic

tactic

converter

apply_congr

binders

interactive

old_conv

linarith

datatypes

elimination

frontend

lemmas

parsing

preprocessing

verification

lint

basic

default

frontend

misc

simp

type_classes

monotonicity

basic

interactive

lemmas

nth_rewrite

basic

congr

default

omega

int

dnf

form

main

preterm

nat

dnf

form

main

neg_elim

preterm

sub_elim

clause

coeffs

eq_elim

find_ees

find_scalars

lin_comb

main

misc

prove_unsats

term

rewrite_all

basic

abel

algebra

alias

apply

apply_fun

auto_cases

binder_matching

cache

cancel_denoms

chain

choose

clear

core

dec_trivial

delta_instance

derive_fintype

derive_inhabited

doc_commands

elide

equiv_rw

explode

ext

fin_cases

find

find_unused

finish

fix_reflect_string

generalize_proofs

generalizes

group

hint

interactive

interactive_expr

interval_cases

lift

local_cache

localized

mk_iff_of_inductive_prop

noncomm_ring

norm_cast

norm_num

obviously

pi_instances

protected

push_neg

rcases

reassoc_axiom

rename_var

replacer

restate_axiom

rewrite

ring

ring2

ring_exp

scc

show_term

simp_command

simp_result

simp_rw

simpa

simps

slice

solve_by_elim

split_ifs

squeeze

subtype_instance

suggest

tauto

tfae

tidy

transfer

transform_decl

transport

trunc_cases

unfold_cases

where

with_local_reducibility

wlog

zify

topology

algebra

affine

continuous_functions

group

group_completion

infinite_sum

module

monoid

multilinear

open_subgroup

ordered

polynomial

ring

uniform_group

uniform_ring

category

Top

adjunctions

basic

epi_mono

limits

open_nhds

opens

TopCommRing

UniformSpace

instances

complex

ennreal

nnreal

real

real_vector_space

metric_space

antilipschitz

baire

basic

cau_seq_filter

closeds

completion

contracting

emetric_space

gluing

gromov_hausdorff

gromov_hausdorff_realized

hausdorff_distance

isometry

lipschitz

pi_Lp

premetric_space

sheaves

presheaf

presheaf_of_functions

sheaf

sheaf_of_functions

stalks

uniform_space

absolute_value

abstract_completion

basic

cauchy

compact_separated

compare_reals

complete_separated

completion

pi

separation

uniform_convergence

uniform_embedding

bases

basic

bounded_continuous_function

compact_open

compacts

constructions

continuous_map

continuous_on

dense_embedding

extend_from_subset

homeomorph

list

local_extr

local_homeomorph

maps

opens

order

path_connected

separation

sequences

stone_cech

subset_properties

tactic

topological_fiber_bundle