url
stringclasses 147
values | commit
stringclasses 147
values | file_path
stringlengths 7
101
| full_name
stringlengths 1
94
| start
stringlengths 6
10
| end
stringlengths 6
11
| tactic
stringlengths 1
11.2k
| state_before
stringlengths 3
2.09M
| state_after
stringlengths 6
2.09M
|
---|---|---|---|---|---|---|---|---|
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.encode_nat_def | [244, 1] | [255, 6] | rfl | case hi.h₂.right.false
n✝ n : ℕ
a✝ : encode n = Memory.mk (decide (n ≠ 0)) (encode (decide (n % 2 = 1))) (encode (n / 2))
hn : n = 0 → false = true
⊢ encodeList (Nat.bits n) = encode n
case hi.h₂.right.true
n✝ n : ℕ
a✝ : encode n = Memory.mk (decide (n ≠ 0)) (encode (decide (n % 2 = 1))) (encode (n / 2))
hn : n = 0 → true = true
⊢ encodeList (Nat.bits n) = encode n | case hi.h₂.right.true
n✝ n : ℕ
a✝ : encode n = Memory.mk (decide (n ≠ 0)) (encode (decide (n % 2 = 1))) (encode (n / 2))
hn : n = 0 → true = true
⊢ encodeList (Nat.bits n) = encode n |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.encode_nat_def | [244, 1] | [255, 6] | rfl | case hi.h₂.right.true
n✝ n : ℕ
a✝ : encode n = Memory.mk (decide (n ≠ 0)) (encode (decide (n % 2 = 1))) (encode (n / 2))
hn : n = 0 → true = true
⊢ encodeList (Nat.bits n) = encode n | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.decode_succ | [269, 9] | [277, 34] | simp [decode_nat] | hd tl : Memory
⊢ decode ℕ (Memory.mk true hd tl) = Option.map (fun n => 2 * n + Bool.toNat (Memory.getv hd)) (decode ℕ tl) | hd tl : Memory
⊢ Option.map (Nat.ofBits ∘ fun b => Memory.getv hd :: b) (decode (List Bool) tl) =
Option.map ((fun n => 2 * n + Bool.toNat (Memory.getv hd)) ∘ Nat.ofBits) (decode (List Bool) tl) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.decode_succ | [269, 9] | [277, 34] | apply congrArg₂ Option.map _ rfl | hd tl : Memory
⊢ Option.map (Nat.ofBits ∘ fun b => Memory.getv hd :: b) (decode (List Bool) tl) =
Option.map ((fun n => 2 * n + Bool.toNat (Memory.getv hd)) ∘ Nat.ofBits) (decode (List Bool) tl) | hd tl : Memory
⊢ (Nat.ofBits ∘ fun b => Memory.getv hd :: b) = (fun n => 2 * n + Bool.toNat (Memory.getv hd)) ∘ Nat.ofBits |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.decode_succ | [269, 9] | [277, 34] | apply funext | hd tl : Memory
⊢ (Nat.ofBits ∘ fun b => Memory.getv hd :: b) = (fun n => 2 * n + Bool.toNat (Memory.getv hd)) ∘ Nat.ofBits | case h
hd tl : Memory
⊢ ∀ (x : List Bool),
(Nat.ofBits ∘ fun b => Memory.getv hd :: b) x = ((fun n => 2 * n + Bool.toNat (Memory.getv hd)) ∘ Nat.ofBits) x |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.decode_succ | [269, 9] | [277, 34] | intro xs | case h
hd tl : Memory
⊢ ∀ (x : List Bool),
(Nat.ofBits ∘ fun b => Memory.getv hd :: b) x = ((fun n => 2 * n + Bool.toNat (Memory.getv hd)) ∘ Nat.ofBits) x | case h
hd tl : Memory
xs : List Bool
⊢ (Nat.ofBits ∘ fun b => Memory.getv hd :: b) xs = ((fun n => 2 * n + Bool.toNat (Memory.getv hd)) ∘ Nat.ofBits) xs |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.decode_succ | [269, 9] | [277, 34] | simp [Nat.ofBits] | case h
hd tl : Memory
xs : List Bool
⊢ (Nat.ofBits ∘ fun b => Memory.getv hd :: b) xs = ((fun n => 2 * n + Bool.toNat (Memory.getv hd)) ∘ Nat.ofBits) xs | case h
hd tl : Memory
xs : List Bool
⊢ Nat.bit (Memory.getv hd) (Nat.ofBits xs) = 2 * Nat.ofBits xs + Bool.toNat (Memory.getv hd) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.decode_succ | [269, 9] | [277, 34] | match HMem.Memory.getv hd with
| true => simp [← Nat.two_mul]
| false => simp [← Nat.two_mul] | case h
hd tl : Memory
xs : List Bool
⊢ Nat.bit (Memory.getv hd) (Nat.ofBits xs) = 2 * Nat.ofBits xs + Bool.toNat (Memory.getv hd) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.decode_succ | [269, 9] | [277, 34] | simp [← Nat.two_mul] | hd tl : Memory
xs : List Bool
⊢ Nat.bit true (Nat.ofBits xs) = 2 * Nat.ofBits xs + Bool.toNat true | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Encoding/Basic.lean | HMem.Encoding.decode_succ | [269, 9] | [277, 34] | simp [← Nat.two_mul] | hd tl : Memory
xs : List Bool
⊢ Nat.bit false (Nat.ofBits xs) = 2 * Nat.ofBits xs + Bool.toNat false | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Memory/Canonical.lean | HMem.Memory.canonical_congr | [87, 1] | [109, 67] | apply absurd (h₁.symm.trans (canonical_nil
(hv.symm.trans (canonical_getOrElse.symm.trans (congrArg (λ t ↦ Tree.getOrElse 1 t false) h₀)))
(hl.symm.trans (canonical_left.trans (congrArg _ h₀)))
(hr.symm.trans (canonical_right.trans (congrArg _ h₀)))))
Tree.noConfusion | v₀ : Bool
lhs₀ rhs₀ t₁ : Tree Bool
hv : Tree.getOrElse 1 (Tree.node v₀ lhs₀ rhs₀) false = Tree.getOrElse 1 t₁ false
hl : canonical (Tree.left (Tree.node v₀ lhs₀ rhs₀)) = canonical (Tree.left t₁)
hr : canonical (Tree.right (Tree.node v₀ lhs₀ rhs₀)) = canonical (Tree.right t₁)
h₀ : canonical (Tree.node v₀ lhs₀ rhs₀) = Tree.nil
h₁ : canonical t₁ = Tree.node (Tree.getOrElse 1 t₁ false) (canonical (Tree.left t₁)) (canonical (Tree.right t₁))
⊢ canonical (Tree.node v₀ lhs₀ rhs₀) = canonical t₁ | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Sound.lean | Option.filter_eq_some' | [12, 9] | [14, 91] | simpa [Option.filter, And.comm (a := Eq b _)] using λ heq ↦ heq ▸ ⟨id, id⟩ | α : Type u_1
f : α → Bool
b✝ b : α
⊢ Option.filter f (some b) = some b✝ ↔ some b = some b✝ ∧ f b✝ = true | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Sound.lean | Option.forall_mem_filter | [16, 1] | [17, 58] | simp | α : Type u_1
f : α → Bool
o : Option α
p : α → Prop
⊢ (∀ y ∈ Option.filter f o, p y) ↔ ∀ x ∈ o, f x = true → p x | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Sound.lean | Option.forall_mem_bind | [22, 1] | [24, 65] | simpa using ⟨ λ h _ hx _ ↦ h _ _ hx, λ h _ _ hx ↦ h _ hx _ ⟩ | α : Type u_1
β : Type u_2
f : α → Option β
o : Option α
p : β → Prop
⊢ (∀ y ∈ Option.bind o f, p y) ↔ ∀ x ∈ o, ∀ y ∈ f x, p y | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Sound.lean | HMem.Trace.TracedProgram.sound_subroutine_arg | [95, 1] | [97, 85] | simp only [hm, Complexity.decode_inv, Option.get_some] | α : Type u_2
inst✝¹ : Complexity.Coding α Memory
β : Type u_3
inst✝ : Complexity.Encoding β Memory
f : α → β
γ : Type u_1
δ : Type
enγ : Complexity.Coding γ Memory
enδ : Complexity.Encoding δ Memory
fs : γ → δ
hc : Complexity.Computable Encoding.Model fs
size : α → ℕ
a : α
dst src : Source
next : TracedProgram
m : Memory
h : sound f size a (subroutine dst src fs next) m
x✝ : γ
hm : Memory.getms m src = Complexity.encode x✝
right✝ : sound f size a next (Memory.setms m dst (Complexity.encode (fs x✝)))
⊢ Memory.getms m src =
Complexity.encode
(Option.get (Complexity.decode γ (Memory.getms m src))
(_ : Option.isSome (Complexity.decode γ (Memory.getms m src)) = true)) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Sound.lean | HMem.Trace.TracedProgram.sound_subroutine_next | [98, 1] | [100, 94] | simpa only [hm, Complexity.decode_inv, Option.get_some] using h | α : Type u_2
inst✝¹ : Complexity.Coding α Memory
β : Type u_3
inst✝ : Complexity.Encoding β Memory
f : α → β
γ : Type u_1
δ : Type
enγ : Complexity.Coding γ Memory
enδ : Complexity.Encoding δ Memory
fs : γ → δ
hc : Complexity.Computable Encoding.Model fs
size : α → ℕ
a : α
dst src : Source
next : TracedProgram
m : Memory
h✝ : sound f size a (subroutine dst src fs next) m
x✝ : γ
hm : Memory.getms m src = Complexity.encode x✝
h : sound f size a next (Memory.setms m dst (Complexity.encode (fs x✝)))
⊢ sound f size a next
(Memory.setms m dst
(Complexity.encode
(fs
(Option.get (Complexity.decode γ (Memory.getms m src))
(_ : Option.isSome (Complexity.decode γ (Memory.getms m src)) = true))))) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Sound.lean | HMem.Trace.TracedProgram.sound_recurse_arg | [108, 1] | [110, 88] | simp only [hm, Complexity.decode_inv, Option.get_some] | α : Type u_2
inst✝¹ : Complexity.Coding α Memory
β : Type u_3
inst✝ : Complexity.Encoding β Memory
f : α → β
γ : Type ?u.37426
δ : Type
enγ : Complexity.Coding γ Memory
enδ : Complexity.Encoding δ Memory
fs : γ → δ
hc : Complexity.Computable Encoding.Model fs
size : α → ℕ
a : α
dst src : Source
next : TracedProgram
m : Memory
h : sound f size a (recurse dst src next) m
x✝ : α
hm : Memory.getms m src = Complexity.encode x✝
left✝ : size x✝ < size a
right✝ : sound f size a next (Memory.setms m dst (Complexity.encode (f x✝)))
⊢ Memory.getms m src =
Complexity.encode
(Option.get (Complexity.decode α (Memory.getms m src))
(_ : Option.isSome (Complexity.decode α (Memory.getms m src)) = true)) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Sound.lean | HMem.Trace.TracedProgram.sound_recurse_size | [111, 1] | [113, 99] | simpa only [hm, Complexity.decode_inv, Option.get_some] using hs | α : Type u_2
inst✝¹ : Complexity.Coding α Memory
β : Type u_3
inst✝ : Complexity.Encoding β Memory
f : α → β
γ : Type ?u.39174
δ : Type
enγ : Complexity.Coding γ Memory
enδ : Complexity.Encoding δ Memory
fs : γ → δ
hc : Complexity.Computable Encoding.Model fs
size : α → ℕ
a : α
dst src : Source
next : TracedProgram
m : Memory
h : sound f size a (recurse dst src next) m
x✝ : α
hm : Memory.getms m src = Complexity.encode x✝
hs : size x✝ < size a
right✝ : sound f size a next (Memory.setms m dst (Complexity.encode (f x✝)))
⊢ size
(Option.get (Complexity.decode α (Memory.getms m src))
(_ : Option.isSome (Complexity.decode α (Memory.getms m src)) = true)) <
size a | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Sound.lean | HMem.Trace.TracedProgram.sound_recurse_next | [114, 1] | [116, 97] | simpa only [hm, Complexity.decode_inv, Option.get_some] using h | α : Type u_2
inst✝¹ : Complexity.Coding α Memory
β : Type u_3
inst✝ : Complexity.Encoding β Memory
f : α → β
γ : Type ?u.40501
δ : Type
enγ : Complexity.Coding γ Memory
enδ : Complexity.Encoding δ Memory
fs : γ → δ
hc : Complexity.Computable Encoding.Model fs
size : α → ℕ
a : α
dst src : Source
next : TracedProgram
m : Memory
h✝ : sound f size a (recurse dst src next) m
x✝ : α
hm : Memory.getms m src = Complexity.encode x✝
left✝ : size x✝ < size a
h : sound f size a next (Memory.setms m dst (Complexity.encode (f x✝)))
⊢ sound f size a next
(Memory.setms m dst
(Complexity.encode
(f
(Option.get (Complexity.decode α (Memory.getms m src))
(_ : Option.isSome (Complexity.decode α (Memory.getms m src)) = true))))) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Complexity/Cost.lean | Complexity.CostFunction.flatMap_none | [155, 1] | [156, 45] | simp[flatMap, h] | α : Type u_3
β : Type u_2
θ : Type u_1
inst✝ : Zero θ
f : α → Option β
a : α
h : f a = none
g : CostFunction β θ
⊢ flatMap f g a = 0 | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Complexity/Cost.lean | Complexity.CostFunction.flatMap_some | [158, 1] | [159, 47] | simp[flatMap, h] | α : Type u_3
β : Type u_2
θ : Type u_1
inst✝ : Zero θ
f : α → Option β
a : α
b : β
h : f a = some b
g : CostFunction β θ
⊢ flatMap f g a = g b | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | List.cons_append_inj | [55, 9] | [56, 58] | simp [-List.cons_append, (List.cons_append _ _ _).symm] | α : Type u_1
a : α
x y z : List α
⊢ a :: (y ++ x) = z ++ x ↔ a :: y = z | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | List.cons₂_append_inj | [58, 9] | [59, 58] | simp [-List.cons_append, (List.cons_append _ _ _).symm] | α : Type u_1
a b : α
x y z : List α
⊢ a :: b :: (y ++ x) = z ++ x ↔ a :: b :: y = z | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.bit_div_2 | [81, 1] | [83, 48] | set_option linter.deprecated false in
cases b <;> dsimp [bit, bit0, bit1] <;> omega | b : Bool
n : ℕ
⊢ bit b n / 2 = n | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.bit_div_2 | [81, 1] | [83, 48] | cases b <;> dsimp [bit, bit0, bit1] <;> omega | b : Bool
n : ℕ
⊢ bit b n / 2 = n | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.pred_lt_iff | [110, 9] | [110, 74] | cases n <;> simp | n : ℕ
⊢ n - 1 < n ↔ n ≠ 0 | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.size_div2 | [113, 9] | [120, 32] | induction n using Nat.binaryRec' with
| z => rfl
| _ _ _ h =>
rw [bit_div_2, size_bit]
apply Eq.symm
apply Nat.pred_succ
apply bit_ne_zero_iff.mpr h | n : ℕ
⊢ size (n / 2) = size n - 1 | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.size_div2 | [113, 9] | [120, 32] | rfl | case z
⊢ size (0 / 2) = size 0 - 1 | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.size_div2 | [113, 9] | [120, 32] | rw [bit_div_2, size_bit] | case f
b✝ : Bool
n✝ : ℕ
h : n✝ = 0 → b✝ = true
a✝ : size (n✝ / 2) = size n✝ - 1
⊢ size (bit b✝ n✝ / 2) = size (bit b✝ n✝) - 1 | case f
b✝ : Bool
n✝ : ℕ
h : n✝ = 0 → b✝ = true
a✝ : size (n✝ / 2) = size n✝ - 1
⊢ size n✝ = succ (size n✝) - 1
case f
b✝ : Bool
n✝ : ℕ
h : n✝ = 0 → b✝ = true
a✝ : size (n✝ / 2) = size n✝ - 1
⊢ bit b✝ n✝ ≠ 0 |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.size_div2 | [113, 9] | [120, 32] | apply Eq.symm | case f
b✝ : Bool
n✝ : ℕ
h : n✝ = 0 → b✝ = true
a✝ : size (n✝ / 2) = size n✝ - 1
⊢ size n✝ = succ (size n✝) - 1
case f
b✝ : Bool
n✝ : ℕ
h : n✝ = 0 → b✝ = true
a✝ : size (n✝ / 2) = size n✝ - 1
⊢ bit b✝ n✝ ≠ 0 | case f.h
b✝ : Bool
n✝ : ℕ
h : n✝ = 0 → b✝ = true
a✝ : size (n✝ / 2) = size n✝ - 1
⊢ succ (size n✝) - 1 = size n✝
case f
b✝ : Bool
n✝ : ℕ
h : n✝ = 0 → b✝ = true
a✝ : size (n✝ / 2) = size n✝ - 1
⊢ bit b✝ n✝ ≠ 0 |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.size_div2 | [113, 9] | [120, 32] | apply Nat.pred_succ | case f.h
b✝ : Bool
n✝ : ℕ
h : n✝ = 0 → b✝ = true
a✝ : size (n✝ / 2) = size n✝ - 1
⊢ succ (size n✝) - 1 = size n✝
case f
b✝ : Bool
n✝ : ℕ
h : n✝ = 0 → b✝ = true
a✝ : size (n✝ / 2) = size n✝ - 1
⊢ bit b✝ n✝ ≠ 0 | case f
b✝ : Bool
n✝ : ℕ
h : n✝ = 0 → b✝ = true
a✝ : size (n✝ / 2) = size n✝ - 1
⊢ bit b✝ n✝ ≠ 0 |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.size_div2 | [113, 9] | [120, 32] | apply bit_ne_zero_iff.mpr h | case f
b✝ : Bool
n✝ : ℕ
h : n✝ = 0 → b✝ = true
a✝ : size (n✝ / 2) = size n✝ - 1
⊢ bit b✝ n✝ ≠ 0 | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.mod_mul | [128, 1] | [149, 75] | match b with
| 0 => simp
| b + 1 =>
match c with
| 0 => simp[Nat.div_add_mod]
| c + 1 =>
apply Eq.trans
apply congrArg₂ _ (Nat.div_add_mod a (b + 1)).symm rfl
apply Eq.trans
apply Nat.add_mod
apply Eq.trans
exact congrArg₂ _ (congrArg₂ _ (Nat.mul_mod_mul_left _ _ _) (Nat.mod_eq_of_lt (lt_of_lt_of_le (Nat.mod_lt _ (Nat.zero_lt_succ _)) (Nat.le_mul_of_pos_right (Nat.zero_lt_succ _))))) rfl
apply Nat.mod_eq_of_lt
apply Nat.lt_of_succ_le
apply le_trans
apply Nat.succ_le_succ
apply add_le_add
apply Nat.mul_le_mul_left
apply Nat.le_of_lt_succ (Nat.mod_lt _ (Nat.zero_lt_succ _))
apply Nat.le_of_lt_succ (Nat.mod_lt _ (Nat.zero_lt_succ _))
simp [Nat.succ_eq_add_one, left_distrib, right_distrib, ← add_assoc] | a b c : ℕ
⊢ a % (b * c) = b * (a / b % c) + a % b | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.mod_mul | [128, 1] | [149, 75] | simp | a b c : ℕ
⊢ a % (0 * c) = 0 * (a / 0 % c) + a % 0 | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.mod_mul | [128, 1] | [149, 75] | match c with
| 0 => simp[Nat.div_add_mod]
| c + 1 =>
apply Eq.trans
apply congrArg₂ _ (Nat.div_add_mod a (b + 1)).symm rfl
apply Eq.trans
apply Nat.add_mod
apply Eq.trans
exact congrArg₂ _ (congrArg₂ _ (Nat.mul_mod_mul_left _ _ _) (Nat.mod_eq_of_lt (lt_of_lt_of_le (Nat.mod_lt _ (Nat.zero_lt_succ _)) (Nat.le_mul_of_pos_right (Nat.zero_lt_succ _))))) rfl
apply Nat.mod_eq_of_lt
apply Nat.lt_of_succ_le
apply le_trans
apply Nat.succ_le_succ
apply add_le_add
apply Nat.mul_le_mul_left
apply Nat.le_of_lt_succ (Nat.mod_lt _ (Nat.zero_lt_succ _))
apply Nat.le_of_lt_succ (Nat.mod_lt _ (Nat.zero_lt_succ _))
simp [Nat.succ_eq_add_one, left_distrib, right_distrib, ← add_assoc] | a b✝ c b : ℕ
⊢ a % ((b + 1) * c) = (b + 1) * (a / (b + 1) % c) + a % (b + 1) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.mod_mul | [128, 1] | [149, 75] | simp[Nat.div_add_mod] | a b✝ c b : ℕ
⊢ a % ((b + 1) * 0) = (b + 1) * (a / (b + 1) % 0) + a % (b + 1) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.mod_mul | [128, 1] | [149, 75] | apply Eq.trans | a b✝ c✝ b c : ℕ
⊢ a % ((b + 1) * (c + 1)) = (b + 1) * (a / (b + 1) % (c + 1)) + a % (b + 1) | case h₁
a b✝ c✝ b c : ℕ
⊢ a % ((b + 1) * (c + 1)) = ?b
case h₂
a b✝ c✝ b c : ℕ
⊢ ?b = (b + 1) * (a / (b + 1) % (c + 1)) + a % (b + 1)
case b
a b✝ c✝ b c : ℕ
⊢ ℕ |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.mod_mul | [128, 1] | [149, 75] | apply congrArg₂ _ (Nat.div_add_mod a (b + 1)).symm rfl | case h₁
a b✝ c✝ b c : ℕ
⊢ a % ((b + 1) * (c + 1)) = ?b
case h₂
a b✝ c✝ b c : ℕ
⊢ ?b = (b + 1) * (a / (b + 1) % (c + 1)) + a % (b + 1)
case b
a b✝ c✝ b c : ℕ
⊢ ℕ | case h₂
a b✝ c✝ b c : ℕ
⊢ ((b + 1) * (a / (b + 1)) + a % (b + 1)) % ((b + 1) * (c + 1)) = (b + 1) * (a / (b + 1) % (c + 1)) + a % (b + 1) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.mod_mul | [128, 1] | [149, 75] | apply Eq.trans | case h₂
a b✝ c✝ b c : ℕ
⊢ ((b + 1) * (a / (b + 1)) + a % (b + 1)) % ((b + 1) * (c + 1)) = (b + 1) * (a / (b + 1) % (c + 1)) + a % (b + 1) | case h₂.h₁
a b✝ c✝ b c : ℕ
⊢ ((b + 1) * (a / (b + 1)) + a % (b + 1)) % ((b + 1) * (c + 1)) = ?h₂.b
case h₂.h₂
a b✝ c✝ b c : ℕ
⊢ ?h₂.b = (b + 1) * (a / (b + 1) % (c + 1)) + a % (b + 1)
case h₂.b
a b✝ c✝ b c : ℕ
⊢ ℕ |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.mod_mul | [128, 1] | [149, 75] | apply Nat.add_mod | case h₂.h₁
a b✝ c✝ b c : ℕ
⊢ ((b + 1) * (a / (b + 1)) + a % (b + 1)) % ((b + 1) * (c + 1)) = ?h₂.b
case h₂.h₂
a b✝ c✝ b c : ℕ
⊢ ?h₂.b = (b + 1) * (a / (b + 1) % (c + 1)) + a % (b + 1)
case h₂.b
a b✝ c✝ b c : ℕ
⊢ ℕ | case h₂.h₂
a b✝ c✝ b c : ℕ
⊢ ((b + 1) * (a / (b + 1)) % ((b + 1) * (c + 1)) + a % (b + 1) % ((b + 1) * (c + 1))) % ((b + 1) * (c + 1)) =
(b + 1) * (a / (b + 1) % (c + 1)) + a % (b + 1) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.mod_mul | [128, 1] | [149, 75] | apply Eq.trans | case h₂.h₂
a b✝ c✝ b c : ℕ
⊢ ((b + 1) * (a / (b + 1)) % ((b + 1) * (c + 1)) + a % (b + 1) % ((b + 1) * (c + 1))) % ((b + 1) * (c + 1)) =
(b + 1) * (a / (b + 1) % (c + 1)) + a % (b + 1) | case h₂.h₂.h₁
a b✝ c✝ b c : ℕ
⊢ ((b + 1) * (a / (b + 1)) % ((b + 1) * (c + 1)) + a % (b + 1) % ((b + 1) * (c + 1))) % ((b + 1) * (c + 1)) = ?h₂.h₂.b
case h₂.h₂.h₂
a b✝ c✝ b c : ℕ
⊢ ?h₂.h₂.b = (b + 1) * (a / (b + 1) % (c + 1)) + a % (b + 1)
case h₂.h₂.b
a b✝ c✝ b c : ℕ
⊢ ℕ |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.mod_mul | [128, 1] | [149, 75] | exact congrArg₂ _ (congrArg₂ _ (Nat.mul_mod_mul_left _ _ _) (Nat.mod_eq_of_lt (lt_of_lt_of_le (Nat.mod_lt _ (Nat.zero_lt_succ _)) (Nat.le_mul_of_pos_right (Nat.zero_lt_succ _))))) rfl | case h₂.h₂.h₁
a b✝ c✝ b c : ℕ
⊢ ((b + 1) * (a / (b + 1)) % ((b + 1) * (c + 1)) + a % (b + 1) % ((b + 1) * (c + 1))) % ((b + 1) * (c + 1)) = ?h₂.h₂.b
case h₂.h₂.h₂
a b✝ c✝ b c : ℕ
⊢ ?h₂.h₂.b = (b + 1) * (a / (b + 1) % (c + 1)) + a % (b + 1)
case h₂.h₂.b
a b✝ c✝ b c : ℕ
⊢ ℕ | case h₂.h₂.h₂
a b✝ c✝ b c : ℕ
⊢ ((b + 1) * (a / (b + 1) % (c + 1)) + a % (b + 1)) % ((b + 1) * (c + 1)) =
(b + 1) * (a / (b + 1) % (c + 1)) + a % (b + 1) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.mod_mul | [128, 1] | [149, 75] | apply Nat.mod_eq_of_lt | case h₂.h₂.h₂
a b✝ c✝ b c : ℕ
⊢ ((b + 1) * (a / (b + 1) % (c + 1)) + a % (b + 1)) % ((b + 1) * (c + 1)) =
(b + 1) * (a / (b + 1) % (c + 1)) + a % (b + 1) | case h₂.h₂.h₂.h
a b✝ c✝ b c : ℕ
⊢ (b + 1) * (a / (b + 1) % (c + 1)) + a % (b + 1) < (b + 1) * (c + 1) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.mod_mul | [128, 1] | [149, 75] | apply Nat.lt_of_succ_le | case h₂.h₂.h₂.h
a b✝ c✝ b c : ℕ
⊢ (b + 1) * (a / (b + 1) % (c + 1)) + a % (b + 1) < (b + 1) * (c + 1) | case h₂.h₂.h₂.h.h
a b✝ c✝ b c : ℕ
⊢ succ ((b + 1) * (a / (b + 1) % (c + 1)) + a % (b + 1)) ≤ (b + 1) * (c + 1) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.mod_mul | [128, 1] | [149, 75] | apply le_trans | case h₂.h₂.h₂.h.h
a b✝ c✝ b c : ℕ
⊢ succ ((b + 1) * (a / (b + 1) % (c + 1)) + a % (b + 1)) ≤ (b + 1) * (c + 1) | case h₂.h₂.h₂.h.h.a
a b✝ c✝ b c : ℕ
⊢ succ ((b + 1) * (a / (b + 1) % (c + 1)) + a % (b + 1)) ≤ ?h₂.h₂.h₂.h.h.b
case h₂.h₂.h₂.h.h.a
a b✝ c✝ b c : ℕ
⊢ ?h₂.h₂.h₂.h.h.b ≤ (b + 1) * (c + 1)
case h₂.h₂.h₂.h.h.b
a b✝ c✝ b c : ℕ
⊢ ℕ |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.mod_mul | [128, 1] | [149, 75] | apply Nat.succ_le_succ | case h₂.h₂.h₂.h.h.a
a b✝ c✝ b c : ℕ
⊢ succ ((b + 1) * (a / (b + 1) % (c + 1)) + a % (b + 1)) ≤ ?h₂.h₂.h₂.h.h.b
case h₂.h₂.h₂.h.h.a
a b✝ c✝ b c : ℕ
⊢ ?h₂.h₂.h₂.h.h.b ≤ (b + 1) * (c + 1)
case h₂.h₂.h₂.h.h.b
a b✝ c✝ b c : ℕ
⊢ ℕ | case h₂.h₂.h₂.h.h.a.a
a b✝ c✝ b c : ℕ
⊢ (b + 1) * (a / (b + 1) % (c + 1)) + a % (b + 1) ≤ ?h₂.h₂.h₂.h.h.a.m
case h₂.h₂.h₂.h.h.a.m
a b✝ c✝ b c : ℕ
⊢ ℕ
case h₂.h₂.h₂.h.h.a
a b✝ c✝ b c : ℕ
⊢ succ ?h₂.h₂.h₂.h.h.a.m ≤ (b + 1) * (c + 1) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.mod_mul | [128, 1] | [149, 75] | apply add_le_add | case h₂.h₂.h₂.h.h.a.a
a b✝ c✝ b c : ℕ
⊢ (b + 1) * (a / (b + 1) % (c + 1)) + a % (b + 1) ≤ ?h₂.h₂.h₂.h.h.a.m
case h₂.h₂.h₂.h.h.a.m
a b✝ c✝ b c : ℕ
⊢ ℕ
case h₂.h₂.h₂.h.h.a
a b✝ c✝ b c : ℕ
⊢ succ ?h₂.h₂.h₂.h.h.a.m ≤ (b + 1) * (c + 1) | case h₂.h₂.h₂.h.h.a.a.h₁
a b✝ c✝ b c : ℕ
⊢ (b + 1) * (a / (b + 1) % (c + 1)) ≤ ?h₂.h₂.h₂.h.h.a.a.b
case h₂.h₂.h₂.h.h.a.a.h₂
a b✝ c✝ b c : ℕ
⊢ a % (b + 1) ≤ ?h₂.h₂.h₂.h.h.a.a.d
case h₂.h₂.h₂.h.h.a.a.b
a b✝ c✝ b c : ℕ
⊢ ℕ
case h₂.h₂.h₂.h.h.a.a.d
a b✝ c✝ b c : ℕ
⊢ ℕ
case h₂.h₂.h₂.h.h.a
a b✝ c✝ b c : ℕ
⊢ succ (?h₂.h₂.h₂.h.h.a.a.b + ?h₂.h₂.h₂.h.h.a.a.d) ≤ (b + 1) * (c + 1) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.mod_mul | [128, 1] | [149, 75] | apply Nat.mul_le_mul_left | case h₂.h₂.h₂.h.h.a.a.h₁
a b✝ c✝ b c : ℕ
⊢ (b + 1) * (a / (b + 1) % (c + 1)) ≤ ?h₂.h₂.h₂.h.h.a.a.b
case h₂.h₂.h₂.h.h.a.a.h₂
a b✝ c✝ b c : ℕ
⊢ a % (b + 1) ≤ ?h₂.h₂.h₂.h.h.a.a.d
case h₂.h₂.h₂.h.h.a.a.b
a b✝ c✝ b c : ℕ
⊢ ℕ
case h₂.h₂.h₂.h.h.a.a.d
a b✝ c✝ b c : ℕ
⊢ ℕ
case h₂.h₂.h₂.h.h.a
a b✝ c✝ b c : ℕ
⊢ succ (?h₂.h₂.h₂.h.h.a.a.b + ?h₂.h₂.h₂.h.h.a.a.d) ≤ (b + 1) * (c + 1) | case h₂.h₂.h₂.h.h.a.a.h₁.h
a b✝ c✝ b c : ℕ
⊢ a / (b + 1) % (c + 1) ≤ ?h₂.h₂.h₂.h.h.a.a.h₁.m
case h₂.h₂.h₂.h.h.a.a.h₁.m
a b✝ c✝ b c : ℕ
⊢ ℕ
case h₂.h₂.h₂.h.h.a.a.h₂
a b✝ c✝ b c : ℕ
⊢ a % (b + 1) ≤ ?h₂.h₂.h₂.h.h.a.a.d
case h₂.h₂.h₂.h.h.a.a.d
a b✝ c✝ b c : ℕ
⊢ ℕ
case h₂.h₂.h₂.h.h.a
a b✝ c✝ b c : ℕ
⊢ succ ((b + 1) * ?h₂.h₂.h₂.h.h.a.a.h₁.m + ?h₂.h₂.h₂.h.h.a.a.d) ≤ (b + 1) * (c + 1) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.mod_mul | [128, 1] | [149, 75] | apply Nat.le_of_lt_succ (Nat.mod_lt _ (Nat.zero_lt_succ _)) | case h₂.h₂.h₂.h.h.a.a.h₁.h
a b✝ c✝ b c : ℕ
⊢ a / (b + 1) % (c + 1) ≤ ?h₂.h₂.h₂.h.h.a.a.h₁.m
case h₂.h₂.h₂.h.h.a.a.h₁.m
a b✝ c✝ b c : ℕ
⊢ ℕ
case h₂.h₂.h₂.h.h.a.a.h₂
a b✝ c✝ b c : ℕ
⊢ a % (b + 1) ≤ ?h₂.h₂.h₂.h.h.a.a.d
case h₂.h₂.h₂.h.h.a.a.d
a b✝ c✝ b c : ℕ
⊢ ℕ
case h₂.h₂.h₂.h.h.a
a b✝ c✝ b c : ℕ
⊢ succ ((b + 1) * ?h₂.h₂.h₂.h.h.a.a.h₁.m + ?h₂.h₂.h₂.h.h.a.a.d) ≤ (b + 1) * (c + 1) | case h₂.h₂.h₂.h.h.a.a.h₂
a b✝ c✝ b c : ℕ
⊢ a % (b + 1) ≤ ?h₂.h₂.h₂.h.h.a.a.d
case h₂.h₂.h₂.h.h.a.a.d
a b✝ c✝ b c : ℕ
⊢ ℕ
case h₂.h₂.h₂.h.h.a
a b✝ c✝ b c : ℕ
⊢ succ ((b + 1) * c + ?h₂.h₂.h₂.h.h.a.a.d) ≤ (b + 1) * (c + 1) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.mod_mul | [128, 1] | [149, 75] | apply Nat.le_of_lt_succ (Nat.mod_lt _ (Nat.zero_lt_succ _)) | case h₂.h₂.h₂.h.h.a.a.h₂
a b✝ c✝ b c : ℕ
⊢ a % (b + 1) ≤ ?h₂.h₂.h₂.h.h.a.a.d
case h₂.h₂.h₂.h.h.a.a.d
a b✝ c✝ b c : ℕ
⊢ ℕ
case h₂.h₂.h₂.h.h.a
a b✝ c✝ b c : ℕ
⊢ succ ((b + 1) * c + ?h₂.h₂.h₂.h.h.a.a.d) ≤ (b + 1) * (c + 1) | case h₂.h₂.h₂.h.h.a
a b✝ c✝ b c : ℕ
⊢ succ ((b + 1) * c + b) ≤ (b + 1) * (c + 1) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.mod_mul | [128, 1] | [149, 75] | simp [Nat.succ_eq_add_one, left_distrib, right_distrib, ← add_assoc] | case h₂.h₂.h₂.h.h.a
a b✝ c✝ b c : ℕ
⊢ succ ((b + 1) * c + b) ≤ (b + 1) * (c + 1) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Bool.majoritySelect_fin | [159, 9] | [167, 23] | decide | ⊢ majoritySelect (decide (↑0 = 1)) (decide (↑0 = 1)) (decide (↑0 = 1)) = decide ((↑0 + ↑0 + ↑0) / 2 = 1) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Bool.majoritySelect_fin | [159, 9] | [167, 23] | decide | ⊢ majoritySelect (decide (↑0 = 1)) (decide (↑0 = 1)) (decide (↑1 = 1)) = decide ((↑0 + ↑0 + ↑1) / 2 = 1) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Bool.majoritySelect_fin | [159, 9] | [167, 23] | decide | ⊢ majoritySelect (decide (↑0 = 1)) (decide (↑1 = 1)) (decide (↑0 = 1)) = decide ((↑0 + ↑1 + ↑0) / 2 = 1) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Bool.majoritySelect_fin | [159, 9] | [167, 23] | decide | ⊢ majoritySelect (decide (↑0 = 1)) (decide (↑1 = 1)) (decide (↑1 = 1)) = decide ((↑0 + ↑1 + ↑1) / 2 = 1) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Bool.majoritySelect_fin | [159, 9] | [167, 23] | decide | ⊢ majoritySelect (decide (↑1 = 1)) (decide (↑0 = 1)) (decide (↑0 = 1)) = decide ((↑1 + ↑0 + ↑0) / 2 = 1) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Bool.majoritySelect_fin | [159, 9] | [167, 23] | decide | ⊢ majoritySelect (decide (↑1 = 1)) (decide (↑0 = 1)) (decide (↑1 = 1)) = decide ((↑1 + ↑0 + ↑1) / 2 = 1) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Bool.majoritySelect_fin | [159, 9] | [167, 23] | decide | ⊢ majoritySelect (decide (↑1 = 1)) (decide (↑1 = 1)) (decide (↑0 = 1)) = decide ((↑1 + ↑1 + ↑0) / 2 = 1) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Bool.majoritySelect_fin | [159, 9] | [167, 23] | decide | ⊢ majoritySelect (decide (↑1 = 1)) (decide (↑1 = 1)) (decide (↑1 = 1)) = decide ((↑1 + ↑1 + ↑1) / 2 = 1) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Bool.xor₃_fin | [169, 9] | [177, 23] | decide | ⊢ xor₃ (decide (↑0 = 1)) (decide (↑0 = 1)) (decide (↑0 = 1)) = decide ((↑0 + ↑0 + ↑0) % 2 = 1) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Bool.xor₃_fin | [169, 9] | [177, 23] | decide | ⊢ xor₃ (decide (↑0 = 1)) (decide (↑0 = 1)) (decide (↑1 = 1)) = decide ((↑0 + ↑0 + ↑1) % 2 = 1) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Bool.xor₃_fin | [169, 9] | [177, 23] | decide | ⊢ xor₃ (decide (↑0 = 1)) (decide (↑1 = 1)) (decide (↑0 = 1)) = decide ((↑0 + ↑1 + ↑0) % 2 = 1) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Bool.xor₃_fin | [169, 9] | [177, 23] | decide | ⊢ xor₃ (decide (↑0 = 1)) (decide (↑1 = 1)) (decide (↑1 = 1)) = decide ((↑0 + ↑1 + ↑1) % 2 = 1) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Bool.xor₃_fin | [169, 9] | [177, 23] | decide | ⊢ xor₃ (decide (↑1 = 1)) (decide (↑0 = 1)) (decide (↑0 = 1)) = decide ((↑1 + ↑0 + ↑0) % 2 = 1) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Bool.xor₃_fin | [169, 9] | [177, 23] | decide | ⊢ xor₃ (decide (↑1 = 1)) (decide (↑0 = 1)) (decide (↑1 = 1)) = decide ((↑1 + ↑0 + ↑1) % 2 = 1) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Bool.xor₃_fin | [169, 9] | [177, 23] | decide | ⊢ xor₃ (decide (↑1 = 1)) (decide (↑1 = 1)) (decide (↑0 = 1)) = decide ((↑1 + ↑1 + ↑0) % 2 = 1) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Bool.xor₃_fin | [169, 9] | [177, 23] | decide | ⊢ xor₃ (decide (↑1 = 1)) (decide (↑1 = 1)) (decide (↑1 = 1)) = decide ((↑1 + ↑1 + ↑1) % 2 = 1) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.not_mod2_eq_zero | [180, 9] | [183, 65] | cases n using binaryRec with
| z => simp
| f b _ _ => cases b <;> simp [← Nat.two_mul, Nat.mul_add_mod] | n : ℕ
⊢ ¬n % 2 = 0 ↔ n % 2 = 1 | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.not_mod2_eq_zero | [180, 9] | [183, 65] | simp | case z
⊢ ¬0 % 2 = 0 ↔ 0 % 2 = 1 | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.not_mod2_eq_zero | [180, 9] | [183, 65] | cases b <;> simp [← Nat.two_mul, Nat.mul_add_mod] | case f
b : Bool
n✝ : ℕ
a✝ : bit b n✝ = n✝ → (¬bit b n✝ % 2 = 0 ↔ bit b n✝ % 2 = 1)
⊢ ¬bit b n✝ % 2 = 0 ↔ bit b n✝ % 2 = 1 | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.log_mul | [186, 1] | [204, 16] | apply le_antisymm | b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ log b (b * n) = log b n + 1 | case a
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ log b (b * n) ≤ log b n + 1
case a
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ log b n + 1 ≤ log b (b * n) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.log_mul | [186, 1] | [204, 16] | apply le_of_eq_of_le | case a
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ log b (b * n) ≤ log b n + 1
case a
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ log b n + 1 ≤ log b (b * n) | case a.h₁
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ log b (b * n) = ?a.b✝
case a.h₂
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ ?a.b✝ ≤ log b n + 1
case a.b
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ ℕ
case a
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ log b n + 1 ≤ log b (b * n) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.log_mul | [186, 1] | [204, 16] | apply Nat.log_of_one_lt_of_le hb | case a.h₁
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ log b (b * n) = ?a.b✝
case a.h₂
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ ?a.b✝ ≤ log b n + 1
case a.b
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ ℕ
case a
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ log b n + 1 ≤ log b (b * n) | case a.h₁
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ b ≤ b * n
case a.h₂
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ log b (b * n / b) + 1 ≤ log b n + 1
case a
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ log b n + 1 ≤ log b (b * n) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.log_mul | [186, 1] | [204, 16] | apply le_of_eq_of_le | case a.h₁
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ b ≤ b * n
case a.h₂
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ log b (b * n / b) + 1 ≤ log b n + 1
case a
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ log b n + 1 ≤ log b (b * n) | case a.h₁.h₁
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ b = ?a.h₁.b✝
case a.h₁.h₂
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ ?a.h₁.b✝ ≤ b * n
case a.h₁.b
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ ℕ
case a.h₂
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ log b (b * n / b) + 1 ≤ log b n + 1
case a
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ log b n + 1 ≤ log b (b * n) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.log_mul | [186, 1] | [204, 16] | apply (mul_one _).symm | case a.h₁.h₁
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ b = ?a.h₁.b✝
case a.h₁.h₂
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ ?a.h₁.b✝ ≤ b * n
case a.h₁.b
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ ℕ
case a.h₂
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ log b (b * n / b) + 1 ≤ log b n + 1
case a
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ log b n + 1 ≤ log b (b * n) | case a.h₁.h₂
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ b * 1 ≤ b * n
case a.h₂
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ log b (b * n / b) + 1 ≤ log b n + 1
case a
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ log b n + 1 ≤ log b (b * n) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.log_mul | [186, 1] | [204, 16] | apply mul_le_mul (le_refl _) hn (zero_le _) (zero_le _) | case a.h₁.h₂
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ b * 1 ≤ b * n
case a.h₂
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ log b (b * n / b) + 1 ≤ log b n + 1
case a
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ log b n + 1 ≤ log b (b * n) | case a.h₂
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ log b (b * n / b) + 1 ≤ log b n + 1
case a
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ log b n + 1 ≤ log b (b * n) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.log_mul | [186, 1] | [204, 16] | apply Nat.succ_le_succ | case a.h₂
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ log b (b * n / b) + 1 ≤ log b n + 1
case a
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ log b n + 1 ≤ log b (b * n) | case a.h₂.a
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ log b (b * n / b) ≤ log b n
case a
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ log b n + 1 ≤ log b (b * n) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.log_mul | [186, 1] | [204, 16] | apply Nat.log_mono_right | case a.h₂.a
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ log b (b * n / b) ≤ log b n
case a
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ log b n + 1 ≤ log b (b * n) | case a.h₂.a.h
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ b * n / b ≤ n
case a
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ log b n + 1 ≤ log b (b * n) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.log_mul | [186, 1] | [204, 16] | apply le_of_eq | case a.h₂.a.h
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ b * n / b ≤ n
case a
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ log b n + 1 ≤ log b (b * n) | case a.h₂.a.h.a
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ b * n / b = n
case a
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ log b n + 1 ≤ log b (b * n) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.log_mul | [186, 1] | [204, 16] | rw [Nat.mul_div_right _ (lt_trans zero_lt_one hb)] | case a.h₂.a.h.a
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ b * n / b = n
case a
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ log b n + 1 ≤ log b (b * n) | case a
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ log b n + 1 ≤ log b (b * n) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.log_mul | [186, 1] | [204, 16] | apply Nat.le_log_of_pow_le hb | case a
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ log b n + 1 ≤ log b (b * n) | case a
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ b ^ (log b n + 1) ≤ b * n |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.log_mul | [186, 1] | [204, 16] | rw [Nat.pow_succ, mul_comm] | case a
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ b ^ (log b n + 1) ≤ b * n | case a
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ b * b ^ log b n ≤ b * n |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.log_mul | [186, 1] | [204, 16] | apply mul_le_mul | case a
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ b * b ^ log b n ≤ b * n | case a.h₁
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ b ≤ b
case a.h₂
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ b ^ log b n ≤ n
case a.c0
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ 0 ≤ b ^ log b n
case a.b0
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ 0 ≤ b |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.log_mul | [186, 1] | [204, 16] | apply le_refl | case a.h₁
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ b ≤ b
case a.h₂
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ b ^ log b n ≤ n
case a.c0
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ 0 ≤ b ^ log b n
case a.b0
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ 0 ≤ b | case a.h₂
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ b ^ log b n ≤ n
case a.c0
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ 0 ≤ b ^ log b n
case a.b0
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ 0 ≤ b |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.log_mul | [186, 1] | [204, 16] | apply Nat.pow_log_le_self | case a.h₂
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ b ^ log b n ≤ n
case a.c0
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ 0 ≤ b ^ log b n
case a.b0
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ 0 ≤ b | case a.h₂.hx
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ n ≠ 0
case a.c0
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ 0 ≤ b ^ log b n
case a.b0
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ 0 ≤ b |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.log_mul | [186, 1] | [204, 16] | apply ne_of_lt' (Nat.lt_of_succ_le hn) | case a.h₂.hx
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ n ≠ 0
case a.c0
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ 0 ≤ b ^ log b n
case a.b0
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ 0 ≤ b | case a.c0
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ 0 ≤ b ^ log b n
case a.b0
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ 0 ≤ b |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.log_mul | [186, 1] | [204, 16] | apply zero_le | case a.c0
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ 0 ≤ b ^ log b n
case a.b0
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ 0 ≤ b | case a.b0
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ 0 ≤ b |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.log_mul | [186, 1] | [204, 16] | apply zero_le | case a.b0
b n : ℕ
hb : 1 < b
hn : 1 ≤ n
⊢ 0 ≤ b | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.log_mul_add | [206, 1] | [223, 21] | apply le_antisymm | b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ log b (b * n + c) = log b n + 1 | case a
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ log b (b * n + c) ≤ log b n + 1
case a
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ log b n + 1 ≤ log b (b * n + c) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.log_mul_add | [206, 1] | [223, 21] | apply le_of_eq_of_le | case a
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ log b (b * n + c) ≤ log b n + 1
case a
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ log b n + 1 ≤ log b (b * n + c) | case a.h₁
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ log b (b * n + c) = ?a.b✝
case a.h₂
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ ?a.b✝ ≤ log b n + 1
case a.b
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ ℕ
case a
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ log b n + 1 ≤ log b (b * n + c) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.log_mul_add | [206, 1] | [223, 21] | apply Nat.log_of_one_lt_of_le hb | case a.h₁
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ log b (b * n + c) = ?a.b✝
case a.h₂
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ ?a.b✝ ≤ log b n + 1
case a.b
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ ℕ
case a
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ log b n + 1 ≤ log b (b * n + c) | case a.h₁
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ b ≤ b * n + c
case a.h₂
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ log b ((b * n + c) / b) + 1 ≤ log b n + 1
case a
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ log b n + 1 ≤ log b (b * n + c) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.log_mul_add | [206, 1] | [223, 21] | apply add_le_add _ (zero_le _) | case a.h₁
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ b ≤ b * n + c
case a.h₂
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ log b ((b * n + c) / b) + 1 ≤ log b n + 1
case a
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ log b n + 1 ≤ log b (b * n + c) | b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ b ≤ b * n
case a.h₂
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ log b ((b * n + c) / b) + 1 ≤ log b n + 1
case a
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ log b n + 1 ≤ log b (b * n + c) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.log_mul_add | [206, 1] | [223, 21] | apply le_of_eq_of_le | b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ b ≤ b * n
case a.h₂
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ log b ((b * n + c) / b) + 1 ≤ log b n + 1
case a
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ log b n + 1 ≤ log b (b * n + c) | case h₁
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ b = ?b
case h₂
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ ?b ≤ b * n
case b
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ ℕ
case a.h₂
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ log b ((b * n + c) / b) + 1 ≤ log b n + 1
case a
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ log b n + 1 ≤ log b (b * n + c) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.log_mul_add | [206, 1] | [223, 21] | apply (mul_one _).symm | case h₁
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ b = ?b
case h₂
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ ?b ≤ b * n
case b
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ ℕ
case a.h₂
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ log b ((b * n + c) / b) + 1 ≤ log b n + 1
case a
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ log b n + 1 ≤ log b (b * n + c) | case h₂
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ b * 1 ≤ b * n
case a.h₂
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ log b ((b * n + c) / b) + 1 ≤ log b n + 1
case a
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ log b n + 1 ≤ log b (b * n + c) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.log_mul_add | [206, 1] | [223, 21] | apply mul_le_mul (le_refl _) hn (zero_le _) (zero_le _) | case h₂
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ b * 1 ≤ b * n
case a.h₂
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ log b ((b * n + c) / b) + 1 ≤ log b n + 1
case a
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ log b n + 1 ≤ log b (b * n + c) | case a.h₂
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ log b ((b * n + c) / b) + 1 ≤ log b n + 1
case a
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ log b n + 1 ≤ log b (b * n + c) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.log_mul_add | [206, 1] | [223, 21] | apply Nat.succ_le_succ | case a.h₂
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ log b ((b * n + c) / b) + 1 ≤ log b n + 1
case a
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ log b n + 1 ≤ log b (b * n + c) | case a.h₂.a
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ log b ((b * n + c) / b) ≤ log b n
case a
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ log b n + 1 ≤ log b (b * n + c) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.log_mul_add | [206, 1] | [223, 21] | apply Nat.log_mono_right | case a.h₂.a
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ log b ((b * n + c) / b) ≤ log b n
case a
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ log b n + 1 ≤ log b (b * n + c) | case a.h₂.a.h
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ (b * n + c) / b ≤ n
case a
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ log b n + 1 ≤ log b (b * n + c) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.log_mul_add | [206, 1] | [223, 21] | apply le_of_eq | case a.h₂.a.h
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ (b * n + c) / b ≤ n
case a
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ log b n + 1 ≤ log b (b * n + c) | case a.h₂.a.h.a
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ (b * n + c) / b = n
case a
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ log b n + 1 ≤ log b (b * n + c) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.log_mul_add | [206, 1] | [223, 21] | apply Eq.trans | case a.h₂.a.h.a
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ (b * n + c) / b = n
case a
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ log b n + 1 ≤ log b (b * n + c) | case a.h₂.a.h.a.h₁
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ (b * n + c) / b = ?a.h₂.a.h.a.b✝
case a.h₂.a.h.a.h₂
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ ?a.h₂.a.h.a.b✝ = n
case a.h₂.a.h.a.b
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ ℕ
case a
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ log b n + 1 ≤ log b (b * n + c) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.log_mul_add | [206, 1] | [223, 21] | apply Nat.mul_add_div (lt_trans zero_lt_one hb) | case a.h₂.a.h.a.h₁
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ (b * n + c) / b = ?a.h₂.a.h.a.b✝
case a.h₂.a.h.a.h₂
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ ?a.h₂.a.h.a.b✝ = n
case a.h₂.a.h.a.b
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ ℕ
case a
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ log b n + 1 ≤ log b (b * n + c) | case a.h₂.a.h.a.h₂
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ n + c / b = n
case a
b n c : ℕ
hb : 1 < b
hn : 1 ≤ n
hc : c < b
⊢ log b n + 1 ≤ log b (b * n + c) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.