tasksource/leandojo huggingface dataset:
Theorem: Nat.Linear.Expr.of_cancel_le
File: src/lean/Init/Data/Nat/Linear.lean

tactic: have := Poly.denote_le_cancel_eq ctx a.toNormPoly b.toNormPoly
state_before: ctx : Context
a b c d : Expr
h : Poly.cancel (toNormPoly a) (toNormPoly b) = (toPoly c, toPoly d)
⊢ (denote ctx a ≤ denote ctx b) = (denote ctx c ≤ denote ctx d)

tactic: rw [h] at this
state_before: ctx : Context
a b c d : Expr
h : Poly.cancel (toNormPoly a) (toNormPoly b) = (toPoly c, toPoly d)
this : Poly.denote_le ctx (Poly.cancel (toNormPoly a) (toNormPoly b)) = Poly.denote_le ctx (toNormPoly a, toNormPoly b)
⊢ (denote ctx a ≤ denote ctx b) = (denote ctx c ≤ denote ctx d)

tactic: simp [toNormPoly, Poly.norm,Poly.denote_le] at this
state_before: ctx : Context
a b c d : Expr
h : Poly.cancel (toNormPoly a) (toNormPoly b) = (toPoly c, toPoly d)
this : Poly.denote_le ctx (toPoly c, toPoly d) = Poly.denote_le ctx (toNormPoly a, toNormPoly b)
⊢ (denote ctx a ≤ denote ctx b) = (denote ctx c ≤ denote ctx d)

tactic: exact this.symm
state_before: ctx : Context
a b c d : Expr
h : Poly.cancel (toNormPoly a) (toNormPoly b) = (toPoly c, toPoly d)
this : (denote ctx c ≤ denote ctx d) = (denote ctx a ≤ denote ctx b)
⊢ (denote ctx a ≤ denote ctx b) = (denote ctx c ≤ denote ctx d)
Theorem: IntermediateField.iInf_toSubfield
File: Mathlib/FieldTheory/Adjoin.lean

tactic: simp [iInf]
state_before: F : Type u_2
inst✝² : Field F
E : Type u_3
inst✝¹ : Field E
inst✝ : Algebra F E
ι : Sort u_1
S : ι → IntermediateField F E
⊢ ↑(toSubfield (iInf S)) = ↑(⨅ (i : ι), toSubfield (S i))
Theorem: MeasurableSet.cond
File: Mathlib/MeasureTheory/MeasurableSpaceDef.lean

tactic: cases i
state_before: α : Type u_1
β : Type ?u.10031
γ : Type ?u.10034
δ : Type ?u.10037
δ' : Type ?u.10040
ι : Sort ?u.10043
s t u : Set α
m : MeasurableSpace α
s₁ s₂ : Set α
h₁ : MeasurableSet s₁
h₂ : MeasurableSet s₂
i : Bool
⊢ MeasurableSet (bif i then s₁ else s₂)

tactic: exacts [h₂, h₁]
state_before: case false
α : Type u_1
β : Type ?u.10031
γ : Type ?u.10034
δ : Type ?u.10037
δ' : Type ?u.10040
ι : Sort ?u.10043
s t u : Set α
m : MeasurableSpace α
s₁ s₂ : Set α
h₁ : MeasurableSet s₁
h₂ : MeasurableSet s₂
⊢ MeasurableSet (bif false then s₁ else s₂)

case true
α : Type u_1
β : Type ?u.10031
γ : Type ?u.10034
δ : Type ?u.10037
δ' : Type ?u.10040
ι : Sort ?u.10043
s t u : Set α
m : MeasurableSpace α
s₁ s₂ : Set α
h₁ : MeasurableSet s₁
h₂ : MeasurableSet s₂
⊢ MeasurableSet (bif true then s₁ else s₂)
Theorem: Polynomial.int_cyclotomic_rw
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean

tactic: simp only [cyclotomic, h, dif_neg, not_false_iff]
state_before: n : ℕ
h : n ≠ 0
⊢ cyclotomic n ℤ =
    Exists.choose (_ : ∃ P, map (Int.castRingHom ℂ) P = cyclotomic' n ℂ ∧ degree P = degree (cyclotomic' n ℂ) ∧ Monic P)

tactic: ext i
state_before: n : ℕ
h : n ≠ 0
⊢ map (Int.castRingHom ℤ)
      (Exists.choose
        (_ : ∃ P, map (Int.castRingHom ℂ) P = cyclotomic' n ℂ ∧ degree P = degree (cyclotomic' n ℂ) ∧ Monic P)) =
    Exists.choose (_ : ∃ P, map (Int.castRingHom ℂ) P = cyclotomic' n ℂ ∧ degree P = degree (cyclotomic' n ℂ) ∧ Monic P)

tactic: simp only [coeff_map, Int.cast_id, eq_intCast]
state_before: case a
n : ℕ
h : n ≠ 0
i : ℕ
⊢ coeff
      (map (Int.castRingHom ℤ)
        (Exists.choose
          (_ : ∃ P, map (Int.castRingHom ℂ) P = cyclotomic' n ℂ ∧ degree P = degree (cyclotomic' n ℂ) ∧ Monic P)))
      i =
    coeff
      (Exists.choose
        (_ : ∃ P, map (Int.castRingHom ℂ) P = cyclotomic' n ℂ ∧ degree P = degree (cyclotomic' n ℂ) ∧ Monic P))
      i
Theorem: IsPrimitiveRoot.zmodEquivZpowers_apply_coe_nat
File: Mathlib/RingTheory/RootsOfUnity/Basic.lean

tactic: have : (i : ZMod k) = (i : ℤ) := by norm_cast
state_before: M : Type ?u.2907804
N : Type ?u.2907807
G : Type ?u.2907810
R : Type u_1
S : Type ?u.2907816
F : Type ?u.2907819
inst✝³ : CommMonoid M
inst✝² : CommMonoid N
inst✝¹ : DivisionCommMonoid G
k l : ℕ
inst✝ : CommRing R
ζ : Rˣ
h : IsPrimitiveRoot ζ k
i : ℕ
⊢ ↑(zmodEquivZpowers h) ↑i = ↑Additive.ofMul { val := ζ ^ i, property := (_ : ∃ y, (fun x x_1 => x ^ x_1) ζ y = ζ ^ i) }

tactic: simp only [this, zmodEquivZpowers_apply_coe_int, zpow_ofNat]
state_before: M : Type ?u.2907804
N : Type ?u.2907807
G : Type ?u.2907810
R : Type u_1
S : Type ?u.2907816
F : Type ?u.2907819
inst✝³ : CommMonoid M
inst✝² : CommMonoid N
inst✝¹ : DivisionCommMonoid G
k l : ℕ
inst✝ : CommRing R
ζ : Rˣ
h : IsPrimitiveRoot ζ k
i : ℕ
this : ↑i = ↑↑i
⊢ ↑(zmodEquivZpowers h) ↑i = ↑Additive.ofMul { val := ζ ^ i, property := (_ : ∃ y, (fun x x_1 => x ^ x_1) ζ y = ζ ^ i) }

tactic: norm_cast
state_before: M : Type ?u.2907804
N : Type ?u.2907807
G : Type ?u.2907810
R : Type u_1
S : Type ?u.2907816
F : Type ?u.2907819
inst✝³ : CommMonoid M
inst✝² : CommMonoid N
inst✝¹ : DivisionCommMonoid G
k l : ℕ
inst✝ : CommRing R
ζ : Rˣ
h : IsPrimitiveRoot ζ k
i : ℕ
⊢ ↑i = ↑↑i
Theorem: Multiset.count_sum
File: Mathlib/Data/Multiset/Bind.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.48922
δ : Type ?u.48925
a✝ : α
s t : Multiset α
f✝ g : α → Multiset β
inst✝ : DecidableEq α
m : Multiset β
f : β → Multiset α
a : α
⊢ count a (sum (map f 0)) = sum (map (fun b => count a (f b)) 0)

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.48922
δ : Type ?u.48925
a✝ : α
s t : Multiset α
f✝ g : α → Multiset β
inst✝ : DecidableEq α
m : Multiset β
f : β → Multiset α
a : α
⊢ ∀ ⦃a_1 : β⦄ {s : Multiset β},
    count a (sum (map f s)) = sum (map (fun b => count a (f b)) s) →
      count a (sum (map f (a_1 ::ₘ s))) = sum (map (fun b => count a (f b)) (a_1 ::ₘ s))
Theorem: Padic.valuation_p
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: have h : (1 : ℝ) < p := by exact_mod_cast (Fact.out : p.Prime).one_lt
state_before: p : ℕ
hp : Fact (Nat.Prime p)
⊢ valuation ↑p = 1

tactic: refine' neg_injective ((zpow_strictMono h).injective <| (norm_eq_pow_val _).symm.trans _)
state_before: p : ℕ
hp : Fact (Nat.Prime p)
h : 1 < ↑p
⊢ valuation ↑p = 1

tactic: exact_mod_cast (Fact.out : p.Prime).one_lt
state_before: p : ℕ
hp : Fact (Nat.Prime p)
⊢ 1 < ↑p

tactic: exact_mod_cast (Fact.out : p.Prime).ne_zero
state_before: case refine'_1
p : ℕ
hp : Fact (Nat.Prime p)
h : 1 < ↑p
⊢ ↑p ≠ 0

tactic: simp
state_before: case refine'_2
p : ℕ
hp : Fact (Nat.Prime p)
h : 1 < ↑p
⊢ ‖↑p‖ = (fun x x_1 => x ^ x_1) (↑p) (-1)
Theorem: Multiset.sub_add_inter
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [inter_comm]
state_before: α : Type u_1
β : Type ?u.193543
γ : Type ?u.193546
inst✝ : DecidableEq α
s✝ t✝ u : Multiset α
a b : α
s t : Multiset α
⊢ s - t + s ∩ t = s

tactic: revert s
state_before: α : Type u_1
β : Type ?u.193543
γ : Type ?u.193546
inst✝ : DecidableEq α
s✝ t✝ u : Multiset α
a b : α
s t : Multiset α
⊢ s - t + t ∩ s = s

tactic: refine' Multiset.induction_on t (by simp) fun a t IH s => _
state_before: α : Type u_1
β : Type ?u.193543
γ : Type ?u.193546
inst✝ : DecidableEq α
s t✝ u : Multiset α
a b : α
t : Multiset α
⊢ ∀ (s : Multiset α), s - t + t ∩ s = s

tactic: by_cases h : a ∈ s
state_before: α : Type u_1
β : Type ?u.193543
γ : Type ?u.193546
inst✝ : DecidableEq α
s✝ t✝¹ u : Multiset α
a✝ b : α
t✝ : Multiset α
a : α
t : Multiset α
IH : ∀ (s : Multiset α), s - t + t ∩ s = s
s : Multiset α
⊢ s - a ::ₘ t + (a ::ₘ t) ∩ s = s

tactic: simp
state_before: α : Type u_1
β : Type ?u.193543
γ : Type ?u.193546
inst✝ : DecidableEq α
s t✝ u : Multiset α
a b : α
t : Multiset α
⊢ ∀ (s : Multiset α), s - 0 + 0 ∩ s = s

tactic: rw [cons_inter_of_pos _ h, sub_cons, add_cons, IH, cons_erase h]
state_before: case pos
α : Type u_1
β : Type ?u.193543
γ : Type ?u.193546
inst✝ : DecidableEq α
s✝ t✝¹ u : Multiset α
a✝ b : α
t✝ : Multiset α
a : α
t : Multiset α
IH : ∀ (s : Multiset α), s - t + t ∩ s = s
s : Multiset α
h : a ∈ s
⊢ s - a ::ₘ t + (a ::ₘ t) ∩ s = s

tactic: rw [cons_inter_of_neg _ h, sub_cons, erase_of_not_mem h, IH]
state_before: case neg
α : Type u_1
β : Type ?u.193543
γ : Type ?u.193546
inst✝ : DecidableEq α
s✝ t✝¹ u : Multiset α
a✝ b : α
t✝ : Multiset α
a : α
t : Multiset α
IH : ∀ (s : Multiset α), s - t + t ∩ s = s
s : Multiset α
h : ¬a ∈ s
⊢ s - a ::ₘ t + (a ::ₘ t) ∩ s = s
Theorem: Polynomial.dickson_two_zero
File: Mathlib/RingTheory/Polynomial/Dickson.lean

tactic: simp only [dickson_zero, pow_zero]
state_before: R : Type u_1
S : Type ?u.114565
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a : R
⊢ dickson 2 0 0 = X ^ 0

tactic: norm_num
state_before: R : Type u_1
S : Type ?u.114565
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a : R
⊢ 3 - ↑2 = 1

tactic: simp only [dickson_one, pow_one]
state_before: R : Type u_1
S : Type ?u.114565
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a : R
⊢ dickson 2 0 1 = X ^ 1

tactic: simp only [dickson_add_two, C_0, MulZeroClass.zero_mul, sub_zero]
state_before: R : Type u_1
S : Type ?u.114565
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a : R
n : ℕ
⊢ dickson 2 0 (n + 2) = X ^ (n + 2)

tactic: rw [dickson_two_zero (n + 1), pow_add X (n + 1) 1, mul_comm, pow_one]
state_before: R : Type u_1
S : Type ?u.114565
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a : R
n : ℕ
⊢ X * dickson 2 0 (n + 1) = X ^ (n + 2)
Theorem: Int.cast_mono
File: Mathlib/Data/Int/Cast/Lemmas.lean

tactic: intro m n h
state_before: F : Type ?u.9302
ι : Type ?u.9305
α : Type u_1
β : Type ?u.9311
inst✝ : OrderedRing α
⊢ Monotone fun x => ↑x

tactic: rw [← sub_nonneg] at h
state_before: F : Type ?u.9302
ι : Type ?u.9305
α : Type u_1
β : Type ?u.9311
inst✝ : OrderedRing α
m n : ℤ
h : m ≤ n
⊢ (fun x => ↑x) m ≤ (fun x => ↑x) n

tactic: lift n - m to ℕ using h with k hk
state_before: F : Type ?u.9302
ι : Type ?u.9305
α : Type u_1
β : Type ?u.9311
inst✝ : OrderedRing α
m n : ℤ
h✝ : m ≤ n
h : 0 ≤ n - m
⊢ (fun x => ↑x) m ≤ (fun x => ↑x) n

tactic: rw [← sub_nonneg, ← cast_sub, ← hk, cast_ofNat]
state_before: case intro
F : Type ?u.9302
ι : Type ?u.9305
α : Type u_1
β : Type ?u.9311
inst✝ : OrderedRing α
m n : ℤ
h : m ≤ n
k : ℕ
hk : ↑k = n - m
⊢ ↑m ≤ ↑n

tactic: exact k.cast_nonneg
state_before: case intro
F : Type ?u.9302
ι : Type ?u.9305
α : Type u_1
β : Type ?u.9311
inst✝ : OrderedRing α
m n : ℤ
h : m ≤ n
k : ℕ
hk : ↑k = n - m
⊢ 0 ≤ ↑k
Theorem: minpoly.dvd_map_of_isScalarTower'
File: Mathlib/FieldTheory/Minpoly/Field.lean

tactic: apply minpoly.dvd K (algebraMap S L s)
state_before: A : Type ?u.57254
B : Type ?u.57257
inst✝¹³ : Field A
inst✝¹² : Ring B
inst✝¹¹ : Algebra A B
x : B
R : Type u_1
S : Type u_2
K : Type u_3
L : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing S
inst✝⁸ : Field K
inst✝⁷ : CommRing L
inst✝⁶ : Algebra R S
inst✝⁵ : Algebra R K
inst✝⁴ : Algebra S L
inst✝³ : Algebra K L
inst✝² : Algebra R L
inst✝¹ : IsScalarTower R K L
inst✝ : IsScalarTower R S L
s : S
⊢ minpoly K (↑(algebraMap S L) s) ∣ map (algebraMap R K) (minpoly R s)

tactic: rw [← map_aeval_eq_aeval_map, minpoly.aeval, map_zero]
state_before: A : Type ?u.57254
B : Type ?u.57257
inst✝¹³ : Field A
inst✝¹² : Ring B
inst✝¹¹ : Algebra A B
x : B
R : Type u_1
S : Type u_2
K : Type u_3
L : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing S
inst✝⁸ : Field K
inst✝⁷ : CommRing L
inst✝⁶ : Algebra R S
inst✝⁵ : Algebra R K
inst✝⁴ : Algebra S L
inst✝³ : Algebra K L
inst✝² : Algebra R L
inst✝¹ : IsScalarTower R K L
inst✝ : IsScalarTower R S L
s : S
⊢ ↑(Polynomial.aeval (↑(algebraMap S L) s)) (map (algebraMap R K) (minpoly R s)) = 0

tactic: rw [← IsScalarTower.algebraMap_eq, ← IsScalarTower.algebraMap_eq]
state_before: case h
A : Type ?u.57254
B : Type ?u.57257
inst✝¹³ : Field A
inst✝¹² : Ring B
inst✝¹¹ : Algebra A B
x : B
R : Type u_1
S : Type u_2
K : Type u_3
L : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing S
inst✝⁸ : Field K
inst✝⁷ : CommRing L
inst✝⁶ : Algebra R S
inst✝⁵ : Algebra R K
inst✝⁴ : Algebra S L
inst✝³ : Algebra K L
inst✝² : Algebra R L
inst✝¹ : IsScalarTower R K L
inst✝ : IsScalarTower R S L
s : S
⊢ RingHom.comp (algebraMap K ((fun x => L) s)) (algebraMap R K) = RingHom.comp (algebraMap S L) (algebraMap R S)
Theorem: Set.projIcc_val
File: Mathlib/Data/Set/Intervals/ProjIcc.lean

tactic: cases x
state_before: α : Type u_1
β : Type ?u.8882
inst✝ : LinearOrder α
a b : α
h : a ≤ b
x✝ : α
x : ↑(Icc a b)
⊢ projIcc a b h ↑x = x

tactic: apply projIcc_of_mem
state_before: case mk
α : Type u_1
β : Type ?u.8882
inst✝ : LinearOrder α
a b : α
h : a ≤ b
x val✝ : α
property✝ : val✝ ∈ Icc a b
⊢ projIcc a b h ↑{ val := val✝, property := property✝ } = { val := val✝, property := property✝ }
Theorem: DirectSum.decompose_coe
File: Mathlib/Algebra/DirectSum/Decomposition.lean

tactic: rw [← decompose_symm_of _, Equiv.apply_symm_apply]
state_before: ι : Type u_3
R : Type ?u.88276
M : Type u_1
σ : Type u_2
inst✝⁴ : DecidableEq ι
inst✝³ : AddCommMonoid M
inst✝² : SetLike σ M
inst✝¹ : AddSubmonoidClass σ M
ℳ : ι → σ
inst✝ : Decomposition ℳ
i : ι
x : { x // x ∈ ℳ i }
⊢ ↑(decompose ℳ) ↑x = ↑(of (fun i => { x // x ∈ ℳ i }) i) x
Theorem: MeasureTheory.norm_indicatorConstLp'
File: Mathlib/MeasureTheory/Function/LpSpace.lean

tactic: by_cases hp_top : p = ∞
state_before: α : Type u_1
E : Type u_2
F : Type ?u.691352
G : Type ?u.691355
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
s : Set α
hs : MeasurableSet s
hμs : ↑↑μ s ≠ ⊤
c : E
hp_pos : p ≠ 0
hμs_pos : ↑↑μ s ≠ 0
⊢ ‖indicatorConstLp p hs hμs c‖ = ‖c‖ * ENNReal.toReal (↑↑μ s) ^ (1 / ENNReal.toReal p)

tactic: rw [hp_top, ENNReal.top_toReal, _root_.div_zero, Real.rpow_zero, mul_one]
state_before: case pos
α : Type u_1
E : Type u_2
F : Type ?u.691352
G : Type ?u.691355
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
s : Set α
hs : MeasurableSet s
hμs : ↑↑μ s ≠ ⊤
c : E
hp_pos : p ≠ 0
hμs_pos : ↑↑μ s ≠ 0
hp_top : p = ⊤
⊢ ‖indicatorConstLp p hs hμs c‖ = ‖c‖ * ENNReal.toReal (↑↑μ s) ^ (1 / ENNReal.toReal p)

tactic: exact norm_indicatorConstLp_top hμs_pos
state_before: case pos
α : Type u_1
E : Type u_2
F : Type ?u.691352
G : Type ?u.691355
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
s : Set α
hs : MeasurableSet s
hμs : ↑↑μ s ≠ ⊤
c : E
hp_pos : p ≠ 0
hμs_pos : ↑↑μ s ≠ 0
hp_top : p = ⊤
⊢ ‖indicatorConstLp ⊤ hs hμs c‖ = ‖c‖

tactic: exact norm_indicatorConstLp hp_pos hp_top
state_before: case neg
α : Type u_1
E : Type u_2
F : Type ?u.691352
G : Type ?u.691355
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
s : Set α
hs : MeasurableSet s
hμs : ↑↑μ s ≠ ⊤
c : E
hp_pos : p ≠ 0
hμs_pos : ↑↑μ s ≠ 0
hp_top : ¬p = ⊤
⊢ ‖indicatorConstLp p hs hμs c‖ = ‖c‖ * ENNReal.toReal (↑↑μ s) ^ (1 / ENNReal.toReal p)
Theorem: Std.RBNode.Balanced.le_size
File: Std/Data/RBMap/Lemmas.lean

tactic: rw [size, Nat.add_right_comm (size _), Nat.add_assoc, depthLB, Nat.pow_succ, Nat.mul_two]
state_before: α : Type u_1
t : RBNode α
c : RBColor
n✝ n : Nat
x✝ y✝ : RBNode α
v✝ : α
hl : Balanced x✝ black n
hr : Balanced y✝ black n
⊢ 2 ^ depthLB red n ≤ size (node red x✝ v✝ y✝) + 1

tactic: exact Nat.add_le_add hl.le_size hr.le_size
state_before: α : Type u_1
t : RBNode α
c : RBColor
n✝ n : Nat
x✝ y✝ : RBNode α
v✝ : α
hl : Balanced x✝ black n
hr : Balanced y✝ black n
⊢ 2 ^ n + 2 ^ n ≤ size x✝ + 1 + (size y✝ + 1)

tactic: rw [size, Nat.add_right_comm (size _), Nat.add_assoc, depthLB, Nat.pow_succ, Nat.mul_two]
state_before: α : Type u_1
t : RBNode α
c : RBColor
n : Nat
x✝ : RBNode α
c₁✝ : RBColor
n✝ : Nat
y✝ : RBNode α
c₂✝ : RBColor
v✝ : α
hl : Balanced x✝ c₁✝ n✝
hr : Balanced y✝ c₂✝ n✝
⊢ 2 ^ depthLB black (n✝ + 1) ≤ size (node black x✝ v✝ y✝) + 1

tactic: refine Nat.add_le_add (Nat.le_trans ?_ hl.le_size) (Nat.le_trans ?_ hr.le_size) <;>
  exact Nat.pow_le_pow_of_le_right (by decide) (depthLB_le ..)
state_before: α : Type u_1
t : RBNode α
c : RBColor
n : Nat
x✝ : RBNode α
c₁✝ : RBColor
n✝ : Nat
y✝ : RBNode α
c₂✝ : RBColor
v✝ : α
hl : Balanced x✝ c₁✝ n✝
hr : Balanced y✝ c₂✝ n✝
⊢ 2 ^ n✝ + 2 ^ n✝ ≤ size x✝ + 1 + (size y✝ + 1)

tactic: decide
state_before: α : Type u_1
t : RBNode α
c : RBColor
n : Nat
x✝ : RBNode α
c₁✝ : RBColor
n✝ : Nat
y✝ : RBNode α
c₂✝ : RBColor
v✝ : α
hl : Balanced x✝ c₁✝ n✝
hr : Balanced y✝ c₂✝ n✝
⊢ 2 > 0
Theorem: AffineMap.restrict.linear_aux
File: Mathlib/LinearAlgebra/AffineSpace/Restrict.lean

tactic: rw [← Submodule.map_le_iff_le_comap, ← AffineSubspace.map_direction]
state_before: k : Type u_1
V₁ : Type u_2
P₁ : Type u_3
V₂ : Type u_4
P₂ : Type u_5
inst✝⁶ : Ring k
inst✝⁵ : AddCommGroup V₁
inst✝⁴ : AddCommGroup V₂
inst✝³ : Module k V₁
inst✝² : Module k V₂
inst✝¹ : AddTorsor V₁ P₁
inst✝ : AddTorsor V₂ P₂
φ : P₁ →ᵃ[k] P₂
E : AffineSubspace k P₁
F : AffineSubspace k P₂
hEF : AffineSubspace.map φ E ≤ F
⊢ AffineSubspace.direction E ≤ Submodule.comap φ.linear (AffineSubspace.direction F)

tactic: exact AffineSubspace.direction_le hEF
state_before: k : Type u_1
V₁ : Type u_2
P₁ : Type u_3
V₂ : Type u_4
P₂ : Type u_5
inst✝⁶ : Ring k
inst✝⁵ : AddCommGroup V₁
inst✝⁴ : AddCommGroup V₂
inst✝³ : Module k V₁
inst✝² : Module k V₂
inst✝¹ : AddTorsor V₁ P₁
inst✝ : AddTorsor V₂ P₂
φ : P₁ →ᵃ[k] P₂
E : AffineSubspace k P₁
F : AffineSubspace k P₂
hEF : AffineSubspace.map φ E ≤ F
⊢ AffineSubspace.direction (AffineSubspace.map φ E) ≤ AffineSubspace.direction F
Theorem: List.subperm_cons_erase
File: Mathlib/Data/List/Perm.lean

tactic: by_cases h : a ∈ l
state_before: α : Type uu
β : Type vv
l₁ l₂ : List α
inst✝ : DecidableEq α
a : α
l : List α
⊢ l <+~ a :: List.erase l a

tactic: exact (perm_cons_erase h).subperm
state_before: case pos
α : Type uu
β : Type vv
l₁ l₂ : List α
inst✝ : DecidableEq α
a : α
l : List α
h : a ∈ l
⊢ l <+~ a :: List.erase l a

tactic: rw [erase_of_not_mem h]
state_before: case neg
α : Type uu
β : Type vv
l₁ l₂ : List α
inst✝ : DecidableEq α
a : α
l : List α
h : ¬a ∈ l
⊢ l <+~ a :: List.erase l a

tactic: exact (sublist_cons _ _).subperm
state_before: case neg
α : Type uu
β : Type vv
l₁ l₂ : List α
inst✝ : DecidableEq α
a : α
l : List α
h : ¬a ∈ l
⊢ l <+~ a :: l
Theorem: Complex.sinh_zero
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [sinh]
state_before: x y : ℂ
⊢ sinh 0 = 0
Theorem: Basis.mem_submodule_iff
File: Mathlib/LinearAlgebra/Basis.lean

tactic: conv_lhs =>
  rw [← P.range_subtype, ← Submodule.map_top, ← b.span_eq, Submodule.map_span, ← Set.range_comp,
      ← Finsupp.range_total]
state_before: ι : Type u_3
ι' : Type ?u.464742
R : Type u_1
R₂ : Type ?u.464748
K : Type ?u.464751
M : Type u_2
M' : Type ?u.464757
M'' : Type ?u.464760
V : Type u
V' : Type ?u.464765
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b✝ b₁ : Basis ι R M
i : ι
c : R
x✝ : M
P : Submodule R M
b : Basis ι R { x // x ∈ P }
x : M
⊢ x ∈ P ↔ ∃ c, x = Finsupp.sum c fun i x => x • ↑(↑b i)

tactic: simp [@eq_comm _ x, Function.comp, Finsupp.total_apply]
state_before: ι : Type u_3
ι' : Type ?u.464742
R : Type u_1
R₂ : Type ?u.464748
K : Type ?u.464751
M : Type u_2
M' : Type ?u.464757
M'' : Type ?u.464760
V : Type u
V' : Type ?u.464765
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b✝ b₁ : Basis ι R M
i : ι
c : R
x✝ : M
P : Submodule R M
b : Basis ι R { x // x ∈ P }
x : M
⊢ x ∈ LinearMap.range (Finsupp.total ι M R (↑(Submodule.subtype P) ∘ ↑b)) ↔
    ∃ c, x = Finsupp.sum c fun i x => x • ↑(↑b i)
Theorem: Set.add_mem_centralizer
File: Mathlib/GroupTheory/Subsemigroup/Centralizer.lean

tactic: rw [add_mul, mul_add, ha c hc, hb c hc]
state_before: M : Type u_1
S T : Set M
a b : M
inst✝ : Distrib M
ha : a ∈ centralizer S
hb : b ∈ centralizer S
c : M
hc : c ∈ S
⊢ c * (a + b) = (a + b) * c
Theorem: LinearMap.trace_prodMap'
File: Mathlib/LinearAlgebra/Trace.lean

tactic: have h := ext_iff.1 (trace_prodMap R M N) (f, g)
state_before: R : Type u_1
inst✝⁹ : CommRing R
M : Type u_2
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
N : Type u_3
inst✝⁶ : AddCommGroup N
inst✝⁵ : Module R N
ι : Type ?u.485168
inst✝⁴ : Module.Free R M
inst✝³ : Module.Finite R M
inst✝² : Module.Free R N
inst✝¹ : Module.Finite R N
inst✝ : Nontrivial R
f : M →ₗ[R] M
g : N →ₗ[R] N
⊢ ↑(trace R (M × N)) (prodMap f g) = ↑(trace R M) f + ↑(trace R N) g

tactic: simp only [coe_comp, Function.comp_apply, prodMap_apply, coprod_apply, id_coe, id.def,
  prodMapLinear_apply] at h
state_before: R : Type u_1
inst✝⁹ : CommRing R
M : Type u_2
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
N : Type u_3
inst✝⁶ : AddCommGroup N
inst✝⁵ : Module R N
ι : Type ?u.485168
inst✝⁴ : Module.Free R M
inst✝³ : Module.Finite R M
inst✝² : Module.Free R N
inst✝¹ : Module.Finite R N
inst✝ : Nontrivial R
f : M →ₗ[R] M
g : N →ₗ[R] N
h :
  ↑(comp (trace R (M × N)) (prodMapLinear R M N M N R)) (f, g) =
    ↑(comp (coprod id id) (prodMap (trace R M) (trace R N))) (f, g)
⊢ ↑(trace R (M × N)) (prodMap f g) = ↑(trace R M) f + ↑(trace R N) g

tactic: exact h
state_before: R : Type u_1
inst✝⁹ : CommRing R
M : Type u_2
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
N : Type u_3
inst✝⁶ : AddCommGroup N
inst✝⁵ : Module R N
ι : Type ?u.485168
inst✝⁴ : Module.Free R M
inst✝³ : Module.Finite R M
inst✝² : Module.Free R N
inst✝¹ : Module.Finite R N
inst✝ : Nontrivial R
f : M →ₗ[R] M
g : N →ₗ[R] N
h : ↑(trace R (M × N)) (prodMap f g) = ↑(trace R M) f + ↑(trace R N) g
⊢ ↑(trace R (M × N)) (prodMap f g) = ↑(trace R M) f + ↑(trace R N) g
Theorem: AddCommGroupCat.kernelIsoKer_hom_comp_subtype
File: Mathlib/Algebra/Category/GroupCat/Limits.lean

tactic: ext
state_before: J : Type v
inst✝ : SmallCategory J
G H : AddCommGroupCat
f : G ⟶ H
⊢ (kernelIsoKer f).hom ≫ AddSubgroup.subtype (AddMonoidHom.ker f) = kernel.ι f

tactic: rfl
state_before: case w
J : Type v
inst✝ : SmallCategory J
G H : AddCommGroupCat
f : G ⟶ H
x✝ : ↑(kernel f)
⊢ ↑((kernelIsoKer f).hom ≫ AddSubgroup.subtype (AddMonoidHom.ker f)) x✝ = ↑(kernel.ι f) x✝
Theorem: CategoryTheory.Subobject.bot_eq_zero
File: Mathlib/CategoryTheory/Subobject/Lattice.lean

tactic: simp
state_before: C : Type u₁
inst✝³ : Category C
X Y Z : C
D : Type u₂
inst✝² : Category D
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
B : C
⊢ (IsInitial.uniqueUpToIso initialIsInitial HasZeroObject.zeroIsInitial).hom ≫ 0 = initial.to B
Theorem: Equiv.Perm.not_solvable
File: Mathlib/GroupTheory/Solvable.lean

tactic: intro h
state_before: G : Type ?u.94765
G' : Type ?u.94768
inst✝¹ : Group G
inst✝ : Group G'
f : G →* G'
X : Type u_1
hX : 5 ≤ Cardinal.mk X
⊢ ¬IsSolvable (Perm X)

tactic: have key : Nonempty (Fin 5 ↪ X) := by
  rwa [← Cardinal.lift_mk_le, Cardinal.mk_fin, Cardinal.lift_natCast, Cardinal.lift_id]
state_before: G : Type ?u.94765
G' : Type ?u.94768
inst✝¹ : Group G
inst✝ : Group G'
f : G →* G'
X : Type u_1
hX : 5 ≤ Cardinal.mk X
h : IsSolvable (Perm X)
⊢ False

tactic: exact
  Equiv.Perm.fin_5_not_solvable
    (solvable_of_solvable_injective (Equiv.Perm.viaEmbeddingHom_injective (Nonempty.some key)))
state_before: G : Type ?u.94765
G' : Type ?u.94768
inst✝¹ : Group G
inst✝ : Group G'
f : G →* G'
X : Type u_1
hX : 5 ≤ Cardinal.mk X
h : IsSolvable (Perm X)
key : Nonempty (Fin 5 ↪ X)
⊢ False

tactic: rwa [← Cardinal.lift_mk_le, Cardinal.mk_fin, Cardinal.lift_natCast, Cardinal.lift_id]
state_before: G : Type ?u.94765
G' : Type ?u.94768
inst✝¹ : Group G
inst✝ : Group G'
f : G →* G'
X : Type u_1
hX : 5 ≤ Cardinal.mk X
h : IsSolvable (Perm X)
⊢ Nonempty (Fin 5 ↪ X)