tasksource/leandojo huggingface dataset:
Theorem: Complex.I_zpow_bit0
File: Mathlib/Data/Complex/Basic.lean

tactic: rw [zpow_bit0', I_mul_I]
state_before: n : ℤ
⊢ I ^ bit0 n = (-1) ^ n
Theorem: iSup₂_le_iff
File: Mathlib/Order/CompleteLattice.lean

tactic: simp_rw [iSup_le_iff]
state_before: α : Type u_1
β : Type ?u.74965
β₂ : Type ?u.74968
γ : Type ?u.74971
ι : Sort u_2
ι' : Sort ?u.74977
κ : ι → Sort u_3
κ' : ι' → Sort ?u.74987
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : (i : ι) → κ i → α
⊢ (⨆ (i : ι) (j : κ i), f i j) ≤ a ↔ ∀ (i : ι) (j : κ i), f i j ≤ a
Theorem: WithTop.coe_sSup'
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

tactic: change _ = ite _ _ _
state_before: α : Type u_1
β : Type ?u.4651
γ : Type ?u.4654
ι : Sort ?u.4657
inst✝¹ : Preorder α
inst✝ : SupSet α
s : Set α
hs : BddAbove s
⊢ ↑(sSup s) = sSup ((fun a => ↑a) '' s)

tactic: rw [if_neg, preimage_image_eq, if_pos hs]
state_before: α : Type u_1
β : Type ?u.4651
γ : Type ?u.4654
ι : Sort ?u.4657
inst✝¹ : Preorder α
inst✝ : SupSet α
s : Set α
hs : BddAbove s
⊢ ↑(sSup s) =
    if ⊤ ∈ (fun a => ↑a) '' s then ⊤
    else
      if BddAbove ((fun a => ↑a) ⁻¹' ((fun a => ↑a) '' s)) then ↑(sSup ((fun a => ↑a) ⁻¹' ((fun a => ↑a) '' s))) else ⊤

tactic: exact Option.some_injective _
state_before: case h
α : Type u_1
β : Type ?u.4651
γ : Type ?u.4654
ι : Sort ?u.4657
inst✝¹ : Preorder α
inst✝ : SupSet α
s : Set α
hs : BddAbove s
⊢ Injective fun a => ↑a

tactic: rintro ⟨x, _, ⟨⟩⟩
state_before: case hnc
α : Type u_1
β : Type ?u.4651
γ : Type ?u.4654
ι : Sort ?u.4657
inst✝¹ : Preorder α
inst✝ : SupSet α
s : Set α
hs : BddAbove s
⊢ ¬⊤ ∈ (fun a => ↑a) '' s
Theorem: HahnSeries.SummableFamily.hsum_embDomain
File: Mathlib/RingTheory/HahnSeries.lean

tactic: ext g
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddCommMonoid R
α : Type u_4
β : Type u_3
s : SummableFamily Γ R α
f : α ↪ β
a : α
b : β
⊢ hsum (embDomain s f) = hsum s

tactic: simp only [hsum_coeff, embDomain_apply, apply_dite HahnSeries.coeff, dite_apply, zero_coeff]
state_before: case coeff.h
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddCommMonoid R
α : Type u_4
β : Type u_3
s : SummableFamily Γ R α
f : α ↪ β
a : α
b : β
g : Γ
⊢ coeff (hsum (embDomain s f)) g = coeff (hsum s) g

tactic: exact finsum_emb_domain f fun a => (s a).coeff g
state_before: case coeff.h
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddCommMonoid R
α : Type u_4
β : Type u_3
s : SummableFamily Γ R α
f : α ↪ β
a : α
b : β
g : Γ
⊢ (∑ᶠ (i : β), if h : i ∈ Set.range ↑f then coeff (toFun s (Classical.choose (_ : i ∈ Set.range ↑f))) g else 0) =
    ∑ᶠ (i : α), coeff (toFun s i) g
Theorem: LiouvilleNumber.remainder_summable
File: Mathlib/NumberTheory/Liouville/LiouvilleNumber.lean

tactic: convert(summable_nat_add_iff (k + 1)).2 (LiouvilleNumber.summable hm)
state_before: m : ℝ
hm : 1 < m
k : ℕ
⊢ Summable fun i => 1 / m ^ (i + (k + 1))!
Theorem: Set.surjOn_iInter
File: Mathlib/Data/Set/Lattice.lean

tactic: intro y hy
state_before: α : Type u_2
β : Type u_3
γ : Type ?u.193360
ι : Sort u_1
ι' : Sort ?u.193366
ι₂ : Sort ?u.193369
κ : ι → Sort ?u.193374
κ₁ : ι → Sort ?u.193379
κ₂ : ι → Sort ?u.193384
κ' : ι' → Sort ?u.193389
inst✝ : Nonempty ι
s : ι → Set α
t : Set β
f : α → β
H : ∀ (i : ι), SurjOn f (s i) t
Hinj : InjOn f (⋃ (i : ι), s i)
⊢ SurjOn f (⋂ (i : ι), s i) t

tactic: rw [Hinj.image_iInter_eq, mem_iInter]
state_before: α : Type u_2
β : Type u_3
γ : Type ?u.193360
ι : Sort u_1
ι' : Sort ?u.193366
ι₂ : Sort ?u.193369
κ : ι → Sort ?u.193374
κ₁ : ι → Sort ?u.193379
κ₂ : ι → Sort ?u.193384
κ' : ι' → Sort ?u.193389
inst✝ : Nonempty ι
s : ι → Set α
t : Set β
f : α → β
H : ∀ (i : ι), SurjOn f (s i) t
Hinj : InjOn f (⋃ (i : ι), s i)
y : β
hy : y ∈ t
⊢ y ∈ f '' ⋂ (i : ι), s i

tactic: exact fun i => H i hy
state_before: α : Type u_2
β : Type u_3
γ : Type ?u.193360
ι : Sort u_1
ι' : Sort ?u.193366
ι₂ : Sort ?u.193369
κ : ι → Sort ?u.193374
κ₁ : ι → Sort ?u.193379
κ₂ : ι → Sort ?u.193384
κ' : ι' → Sort ?u.193389
inst✝ : Nonempty ι
s : ι → Set α
t : Set β
f : α → β
H : ∀ (i : ι), SurjOn f (s i) t
Hinj : InjOn f (⋃ (i : ι), s i)
y : β
hy : y ∈ t
⊢ ∀ (i : ι), y ∈ f '' s i
Theorem: Finmap.dlookup_list_toFinmap
File: Mathlib/Data/Finmap.lean

tactic: rw [List.toFinmap, lookup_toFinmap, lookup_to_alist]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
s : List (Sigma β)
⊢ lookup a (List.toFinmap s) = dlookup a s
Theorem: Associates.mem_factors'_iff_dvd
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: constructor
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝ : UniqueFactorizationMonoid α
dec : DecidableEq α
dec' : DecidableEq (Associates α)
a p : α
ha0 : a ≠ 0
hp : Irreducible p
⊢ { val := Associates.mk p, property := (_ : Irreducible (Associates.mk p)) } ∈ factors' a ↔ p ∣ a

tactic: rw [← mk_dvd_mk]
state_before: case mp
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝ : UniqueFactorizationMonoid α
dec : DecidableEq α
dec' : DecidableEq (Associates α)
a p : α
ha0 : a ≠ 0
hp : Irreducible p
⊢ { val := Associates.mk p, property := (_ : Irreducible (Associates.mk p)) } ∈ factors' a → p ∣ a

tactic: apply dvd_of_mem_factors'
state_before: case mp
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝ : UniqueFactorizationMonoid α
dec : DecidableEq α
dec' : DecidableEq (Associates α)
a p : α
ha0 : a ≠ 0
hp : Irreducible p
⊢ { val := Associates.mk p, property := (_ : Irreducible (Associates.mk p)) } ∈ factors' a →
    Associates.mk p ∣ Associates.mk a

tactic: apply ha0
state_before: case mp.hz
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝ : UniqueFactorizationMonoid α
dec : DecidableEq α
dec' : DecidableEq (Associates α)
a p : α
ha0 : a ≠ 0
hp : Irreducible p
⊢ a ≠ 0

tactic: apply mem_factors'_of_dvd ha0 hp
state_before: case mpr
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝ : UniqueFactorizationMonoid α
dec : DecidableEq α
dec' : DecidableEq (Associates α)
a p : α
ha0 : a ≠ 0
hp : Irreducible p
⊢ p ∣ a → { val := Associates.mk p, property := (_ : Irreducible (Associates.mk p)) } ∈ factors' a
Theorem: Polynomial.derivWithin_aeval
File: Mathlib/Analysis/Calculus/Deriv/Polynomial.lean

tactic: simpa only [aeval_def, eval₂_eq_eval_map, derivative_map] using
  (q.map (algebraMap R 𝕜)).derivWithin hxs
state_before: 𝕜 : Type u
inst✝⁶ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
E : Type w
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
R : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Algebra R 𝕜
p : 𝕜[X]
q : R[X]
hxs : UniqueDiffWithinAt 𝕜 s x
⊢ derivWithin (fun x => ↑(aeval x) q) s x = ↑(aeval x) (↑derivative q)
Theorem: bddAbove_lowerClosure
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp_rw [BddAbove, upperBounds_lowerClosure]
state_before: α : Type u_1
β : Type ?u.165959
γ : Type ?u.165962
ι : Sort ?u.165965
κ : ι → Sort ?u.165970
inst✝¹ : Preorder α
inst✝ : Preorder β
s t : Set α
x : α
⊢ BddAbove ↑(lowerClosure s) ↔ BddAbove s
Theorem: Cardinal.lift_iSup_le
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [lift_iSup hf]
state_before: α β : Type u
ι : Type v
f : ι → Cardinal
t : Cardinal
hf : BddAbove (range f)
w : ∀ (i : ι), lift (f i) ≤ t
⊢ lift (iSup f) ≤ t

tactic: exact ciSup_le' w
state_before: α β : Type u
ι : Type v
f : ι → Cardinal
t : Cardinal
hf : BddAbove (range f)
w : ∀ (i : ι), lift (f i) ≤ t
⊢ (⨆ (i : ι), lift (f i)) ≤ t
Theorem: Polynomial.support_integralNormalization
File: Mathlib/Data/Polynomial/IntegralNormalization.lean

tactic: by_cases hf : f = 0
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝¹ : Ring R
inst✝ : IsDomain R
f : R[X]
⊢ support (integralNormalization f) = support f

tactic: ext i
state_before: case neg
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝¹ : Ring R
inst✝ : IsDomain R
f : R[X]
hf : ¬f = 0
⊢ support (integralNormalization f) = support f

tactic: refine' ⟨fun h => integralNormalization_support h, _⟩
state_before: case neg.a
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝¹ : Ring R
inst✝ : IsDomain R
f : R[X]
hf : ¬f = 0
i : ℕ
⊢ i ∈ support (integralNormalization f) ↔ i ∈ support f

tactic: simp only [integralNormalization_coeff, mem_support_iff]
state_before: case neg.a
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝¹ : Ring R
inst✝ : IsDomain R
f : R[X]
hf : ¬f = 0
i : ℕ
⊢ i ∈ support f → i ∈ support (integralNormalization f)

tactic: intro hfi
state_before: case neg.a
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝¹ : Ring R
inst✝ : IsDomain R
f : R[X]
hf : ¬f = 0
i : ℕ
⊢ coeff f i ≠ 0 → (if degree f = ↑i then 1 else coeff f i * leadingCoeff f ^ (natDegree f - 1 - i)) ≠ 0

tactic: split_ifs with hi <;> simp [hfi, hi, pow_ne_zero _ (leadingCoeff_ne_zero.mpr hf)]
state_before: case neg.a
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝¹ : Ring R
inst✝ : IsDomain R
f : R[X]
hf : ¬f = 0
i : ℕ
hfi : coeff f i ≠ 0
⊢ (if degree f = ↑i then 1 else coeff f i * leadingCoeff f ^ (natDegree f - 1 - i)) ≠ 0

tactic: simp [hf]
state_before: case pos
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝¹ : Ring R
inst✝ : IsDomain R
f : R[X]
hf : f = 0
⊢ support (integralNormalization f) = support f
Theorem: InnerProductSpace.Core.ofReal_normSq_eq_inner_self
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [ext_iff]
state_before: 𝕜 : Type u_1
E : Type ?u.365837
F : Type u_2
inst✝² : IsROrC 𝕜
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
x : F
⊢ ↑(normSq x) = inner x x

tactic: exact ⟨by simp only [ofReal_re]; rfl, by simp only [inner_self_im, ofReal_im]⟩
state_before: 𝕜 : Type u_1
E : Type ?u.365837
F : Type u_2
inst✝² : IsROrC 𝕜
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
x : F
⊢ ↑re ↑(normSq x) = ↑re (inner x x) ∧ ↑im ↑(normSq x) = ↑im (inner x x)

tactic: simp only [ofReal_re]
state_before: 𝕜 : Type u_1
E : Type ?u.365837
F : Type u_2
inst✝² : IsROrC 𝕜
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
x : F
⊢ ↑re ↑(normSq x) = ↑re (inner x x)

tactic: rfl
state_before: 𝕜 : Type u_1
E : Type ?u.365837
F : Type u_2
inst✝² : IsROrC 𝕜
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
x : F
⊢ normSq x = ↑re (inner x x)

tactic: simp only [inner_self_im, ofReal_im]
state_before: 𝕜 : Type u_1
E : Type ?u.365837
F : Type u_2
inst✝² : IsROrC 𝕜
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
x : F
⊢ ↑im ↑(normSq x) = ↑im (inner x x)
Theorem: essInf_antitone_measure
File: Mathlib/MeasureTheory/Function/EssSup.lean

tactic: refine' liminf_le_liminf_of_le (Measure.ae_le_iff_absolutelyContinuous.mpr hμν) _ _
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : MeasureTheory.Measure α
inst✝ : CompleteLattice β
f : α → β
hμν : μ ≪ ν
⊢ essInf f ν ≤ essInf f μ

tactic: all_goals isBoundedDefault
state_before: case refine'_1
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : MeasureTheory.Measure α
inst✝ : CompleteLattice β
f : α → β
hμν : μ ≪ ν
⊢ IsBoundedUnder (fun x x_1 => x ≥ x_1) (Measure.ae ν) f

case refine'_2
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : MeasureTheory.Measure α
inst✝ : CompleteLattice β
f : α → β
hμν : μ ≪ ν
⊢ IsCoboundedUnder (fun x x_1 => x ≥ x_1) (Measure.ae μ) f

tactic: isBoundedDefault
state_before: case refine'_2
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : MeasureTheory.Measure α
inst✝ : CompleteLattice β
f : α → β
hμν : μ ≪ ν
⊢ IsCoboundedUnder (fun x x_1 => x ≥ x_1) (Measure.ae μ) f
Theorem: Polynomial.dickson_one_one_eq_chebyshev_T
File: Mathlib/RingTheory/Polynomial/Dickson.lean

tactic: simp only [Chebyshev.T_zero, mul_one, one_comp, dickson_zero]
state_before: R : Type u_1
S : Type ?u.173812
inst✝² : CommRing R
inst✝¹ : CommRing S
k : ℕ
a : R
inst✝ : Invertible 2
⊢ dickson 1 1 0 = 2 * comp (Chebyshev.T R 0) (↑C ⅟2 * X)

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

tactic: rw [dickson_one, Chebyshev.T_one, X_comp, ← mul_assoc, two_mul_C_half_eq_one, one_mul]
state_before: R : Type u_1
S : Type ?u.173812
inst✝² : CommRing R
inst✝¹ : CommRing S
k : ℕ
a : R
inst✝ : Invertible 2
⊢ dickson 1 1 1 = 2 * comp (Chebyshev.T R 1) (↑C ⅟2 * X)

tactic: rw [dickson_add_two, C_1, Chebyshev.T_add_two, dickson_one_one_eq_chebyshev_T (n + 1),
  dickson_one_one_eq_chebyshev_T n, sub_comp, mul_comp, mul_comp, X_comp, ofNat_comp]
state_before: R : Type u_1
S : Type ?u.173812
inst✝² : CommRing R
inst✝¹ : CommRing S
k : ℕ
a : R
inst✝ : Invertible 2
n : ℕ
⊢ dickson 1 1 (n + 2) = 2 * comp (Chebyshev.T R (n + 2)) (↑C ⅟2 * X)

tactic: simp_rw [← mul_assoc, Nat.cast_ofNat, two_mul_C_half_eq_one]
state_before: R : Type u_1
S : Type ?u.173812
inst✝² : CommRing R
inst✝¹ : CommRing S
k : ℕ
a : R
inst✝ : Invertible 2
n : ℕ
⊢ X * (2 * comp (Chebyshev.T R (n + 1)) (↑C ⅟2 * X)) - 1 * (2 * comp (Chebyshev.T R n) (↑C ⅟2 * X)) =
    2 * (↑2 * (↑C ⅟2 * X) * comp (Chebyshev.T R (n + 1)) (↑C ⅟2 * X) - comp (Chebyshev.T R n) (↑C ⅟2 * X))

tactic: ring
state_before: R : Type u_1
S : Type ?u.173812
inst✝² : CommRing R
inst✝¹ : CommRing S
k : ℕ
a : R
inst✝ : Invertible 2
n : ℕ
⊢ X * 2 * comp (Chebyshev.T R (n + 1)) (↑C ⅟2 * X) - 1 * 2 * comp (Chebyshev.T R n) (↑C ⅟2 * X) =
    2 * (1 * X * comp (Chebyshev.T R (n + 1)) (↑C ⅟2 * X) - comp (Chebyshev.T R n) (↑C ⅟2 * X))
Theorem: Polynomial.ne_zero_of_natDegree_gt
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: simp [H, Nat.not_lt_zero] at h
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.467364
n : ℕ
h : n < natDegree p
H : p = 0
⊢ False
Theorem: LieHom.ext_iff
File: Mathlib/Algebra/Lie/Basic.lean

tactic: rintro rfl x
state_before: R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieAlgebra R L₁
inst✝³ : LieRing L₂
inst✝² : LieAlgebra R L₂
inst✝¹ : LieRing L₃
inst✝ : LieAlgebra R L₃
f g : L₁ →ₗ⁅R⁆ L₂
⊢ f = g → ∀ (x : L₁), ↑f x = ↑g x

tactic: rfl
state_before: R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieAlgebra R L₁
inst✝³ : LieRing L₂
inst✝² : LieAlgebra R L₂
inst✝¹ : LieRing L₃
inst✝ : LieAlgebra R L₃
f : L₁ →ₗ⁅R⁆ L₂
x : L₁
⊢ ↑f x = ↑f x
Theorem: Multiset.mem_singleton
File: Mathlib/Data/Multiset/Basic.lean

tactic: simp only [← cons_zero, mem_cons, iff_self_iff, or_false_iff, not_mem_zero]
state_before: α : Type u_1
β : Type ?u.25056
γ : Type ?u.25059
a b : α
⊢ b ∈ {a} ↔ b = a
Theorem: smul_closedUnitBall_of_nonneg
File: Mathlib/Analysis/NormedSpace/Pointwise.lean

tactic: rw [smul_closedUnitBall, Real.norm_of_nonneg hr]
state_before: 𝕜 : Type ?u.1761797
E : Type u_1
inst✝³ : NormedField 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
r : ℝ
hr : 0 ≤ r
⊢ r • closedBall 0 1 = closedBall 0 r
Theorem: Nat.digits_eq_cons_digits_div
File: Mathlib/Data/Nat/Digits.lean

tactic: rcases b with (_ | _ | b)
state_before: n✝ b n : ℕ
h : 1 < b
w : n ≠ 0
⊢ digits b n = n % b :: digits b (n / b)

tactic: rcases n with (_ | n)
state_before: case succ.succ
n✝ n : ℕ
w : n ≠ 0
b : ℕ
h : 1 < succ (succ b)
⊢ digits (succ (succ b)) n = n % succ (succ b) :: digits (succ (succ b)) (n / succ (succ b))

tactic: . simp only [digits_add_two_add_one, ne_eq]
state_before: case succ.succ.succ
n✝ b : ℕ
h : 1 < succ (succ b)
n : ℕ
w : succ n ≠ 0
⊢ digits (succ (succ b)) (succ n) = succ n % succ (succ b) :: digits (succ (succ b)) (succ n / succ (succ b))

tactic: rw [digits_zero_succ' w, Nat.mod_zero, Nat.div_zero, Nat.digits_zero_zero]
state_before: case zero
n✝ n : ℕ
w : n ≠ 0
h : 1 < zero
⊢ digits zero n = n % zero :: digits zero (n / zero)

tactic: norm_num at h
state_before: case succ.zero
n✝ n : ℕ
w : n ≠ 0
h : 1 < succ zero
⊢ digits (succ zero) n = n % succ zero :: digits (succ zero) (n / succ zero)

tactic: norm_num at w
state_before: case succ.succ.zero
n b : ℕ
h : 1 < succ (succ b)
w : zero ≠ 0
⊢ digits (succ (succ b)) zero = zero % succ (succ b) :: digits (succ (succ b)) (zero / succ (succ b))

tactic: simp only [digits_add_two_add_one, ne_eq]
state_before: case succ.succ.succ
n✝ b : ℕ
h : 1 < succ (succ b)
n : ℕ
w : succ n ≠ 0
⊢ digits (succ (succ b)) (succ n) = succ n % succ (succ b) :: digits (succ (succ b)) (succ n / succ (succ b))
Theorem: CategoryTheory.Subobject.ind₂
File: Mathlib/CategoryTheory/Subobject/Basic.lean

tactic: apply Quotient.inductionOn₂'
state_before: C : Type u₁
inst✝¹ : Category C
X✝ Y Z : C
D : Type u₂
inst✝ : Category D
X : C
p : Subobject X → Subobject X → Prop
h : ∀ ⦃A B : C⦄ (f : A ⟶ X) (g : B ⟶ X) [inst : Mono f] [inst_1 : Mono g], p (mk f) (mk g)
P Q : Subobject X
⊢ p P Q

tactic: intro a b
state_before: case h
C : Type u₁
inst✝¹ : Category C
X✝ Y Z : C
D : Type u₂
inst✝ : Category D
X : C
p : Subobject X → Subobject X → Prop
h : ∀ ⦃A B : C⦄ (f : A ⟶ X) (g : B ⟶ X) [inst : Mono f] [inst_1 : Mono g], p (mk f) (mk g)
P Q : Subobject X
⊢ ∀ (a₁ a₂ : MonoOver X), p (Quotient.mk'' a₁) (Quotient.mk'' a₂)

tactic: exact h a.arrow b.arrow
state_before: case h
C : Type u₁
inst✝¹ : Category C
X✝ Y Z : C
D : Type u₂
inst✝ : Category D
X : C
p : Subobject X → Subobject X → Prop
h : ∀ ⦃A B : C⦄ (f : A ⟶ X) (g : B ⟶ X) [inst : Mono f] [inst_1 : Mono g], p (mk f) (mk g)
P Q : Subobject X
a b : MonoOver X
⊢ p (Quotient.mk'' a) (Quotient.mk'' b)
Theorem: Int.mod_eq_emod
File: Std/Data/Int/DivMod.lean

tactic: simp [emod_def, mod_def, div_eq_ediv ha hb]
state_before: a b : Int
ha : 0 ≤ a
hb : 0 ≤ b
⊢ mod a b = a % b
Theorem: exp_op
File: Mathlib/Analysis/NormedSpace/Exponential.lean

tactic: simp_rw [exp, expSeries_sum_eq, ← MulOpposite.op_pow, ← MulOpposite.op_smul, tsum_op]
state_before: 𝕂 : Type u_2
𝔸 : Type u_1
inst✝⁵ : Field 𝕂
inst✝⁴ : Ring 𝔸
inst✝³ : Algebra 𝕂 𝔸
inst✝² : TopologicalSpace 𝔸
inst✝¹ : TopologicalRing 𝔸
inst✝ : T2Space 𝔸
x : 𝔸
⊢ exp 𝕂 (MulOpposite.op x) = MulOpposite.op (exp 𝕂 x)
Theorem: Fin.prod_univ_def
File: Mathlib/Algebra/BigOperators/Fin.lean

tactic: simp [univ_def]
state_before: α : Type ?u.464
β : Type u_1
inst✝ : CommMonoid β
n : ℕ
f : Fin n → β
⊢ ∏ i : Fin n, f i = List.prod (List.map f (List.finRange n))
Theorem: MvPolynomial.eval₂Hom_X
File: Mathlib/Data/MvPolynomial/CommRing.lean

tactic: apply MvPolynomial.induction_on x
  (fun n => by
    rw [hom_C f, eval₂_C]
    exact eq_intCast c n)
  (fun p q hp hq => by
    rw [eval₂_add, hp, hq]
    exact (f.map_add _ _).symm)
  (fun p n hp => by
    rw [eval₂_mul, eval₂_X, hp]
    exact (f.map_mul _ _).symm)
state_before: R✝ : Type u
S : Type v
σ : Type ?u.162485
a a' a₁ a₂ : R✝
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommRing R✝
p q : MvPolynomial σ R✝
inst✝ : CommRing S
f✝ : R✝ →+* S
g : σ → S
R : Type u
c : ℤ →+* S
f : MvPolynomial R ℤ →+* S
x : MvPolynomial R ℤ
⊢ eval₂ c (↑f ∘ X) x = ↑f x

tactic: rw [hom_C f, eval₂_C]
state_before: R✝ : Type u
S : Type v
σ : Type ?u.162485
a a' a₁ a₂ : R✝
e : ℕ
n✝ m : σ
s : σ →₀ ℕ
inst✝¹ : CommRing R✝
p q : MvPolynomial σ R✝
inst✝ : CommRing S
f✝ : R✝ →+* S
g : σ → S
R : Type u
c : ℤ →+* S
f : MvPolynomial R ℤ →+* S
x : MvPolynomial R ℤ
n : ℤ
⊢ eval₂ c (↑f ∘ X) (↑C n) = ↑f (↑C n)

tactic: exact eq_intCast c n
state_before: R✝ : Type u
S : Type v
σ : Type ?u.162485
a a' a₁ a₂ : R✝
e : ℕ
n✝ m : σ
s : σ →₀ ℕ
inst✝¹ : CommRing R✝
p q : MvPolynomial σ R✝
inst✝ : CommRing S
f✝ : R✝ →+* S
g : σ → S
R : Type u
c : ℤ →+* S
f : MvPolynomial R ℤ →+* S
x : MvPolynomial R ℤ
n : ℤ
⊢ ↑c n = ↑n

tactic: rw [eval₂_add, hp, hq]
state_before: R✝ : Type u
S : Type v
σ : Type ?u.162485
a a' a₁ a₂ : R✝
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommRing R✝
p✝ q✝ : MvPolynomial σ R✝
inst✝ : CommRing S
f✝ : R✝ →+* S
g : σ → S
R : Type u
c : ℤ →+* S
f : MvPolynomial R ℤ →+* S
x p q : MvPolynomial R ℤ
hp : eval₂ c (↑f ∘ X) p = ↑f p
hq : eval₂ c (↑f ∘ X) q = ↑f q
⊢ eval₂ c (↑f ∘ X) (p + q) = ↑f (p + q)

tactic: exact (f.map_add _ _).symm
state_before: R✝ : Type u
S : Type v
σ : Type ?u.162485
a a' a₁ a₂ : R✝
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommRing R✝
p✝ q✝ : MvPolynomial σ R✝
inst✝ : CommRing S
f✝ : R✝ →+* S
g : σ → S
R : Type u
c : ℤ →+* S
f : MvPolynomial R ℤ →+* S
x p q : MvPolynomial R ℤ
hp : eval₂ c (↑f ∘ X) p = ↑f p
hq : eval₂ c (↑f ∘ X) q = ↑f q
⊢ ↑f p + ↑f q = ↑f (p + q)

tactic: rw [eval₂_mul, eval₂_X, hp]
state_before: R✝ : Type u
S : Type v
σ : Type ?u.162485
a a' a₁ a₂ : R✝
e : ℕ
n✝ m : σ
s : σ →₀ ℕ
inst✝¹ : CommRing R✝
p✝ q : MvPolynomial σ R✝
inst✝ : CommRing S
f✝ : R✝ →+* S
g : σ → S
R : Type u
c : ℤ →+* S
f : MvPolynomial R ℤ →+* S
x p : MvPolynomial R ℤ
n : R
hp : eval₂ c (↑f ∘ X) p = ↑f p
⊢ eval₂ c (↑f ∘ X) (p * X n) = ↑f (p * X n)

tactic: exact (f.map_mul _ _).symm
state_before: R✝ : Type u
S : Type v
σ : Type ?u.162485
a a' a₁ a₂ : R✝
e : ℕ
n✝ m : σ
s : σ →₀ ℕ
inst✝¹ : CommRing R✝
p✝ q : MvPolynomial σ R✝
inst✝ : CommRing S
f✝ : R✝ →+* S
g : σ → S
R : Type u
c : ℤ →+* S
f : MvPolynomial R ℤ →+* S
x p : MvPolynomial R ℤ
n : R
hp : eval₂ c (↑f ∘ X) p = ↑f p
⊢ ↑f p * (↑f ∘ X) n = ↑f (p * X n)
Theorem: Ordinal.add_le_right_iff_mul_omega_le
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

tactic: rw [← add_eq_right_iff_mul_omega_le]
state_before: a b : Ordinal
⊢ a + b ≤ b ↔ a * ω ≤ b

tactic: exact (add_isNormal a).le_iff_eq
state_before: a b : Ordinal
⊢ a + b ≤ b ↔ a + b = b
Theorem: Real.volume_Ioi
File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

tactic: simp
state_before: ι : Type ?u.243161
inst✝ : Fintype ι
a : ℝ
n : ℕ
⊢ ↑n = ↑↑volume (Ioo a (a + ↑n))
Theorem: CategoryTheory.GrothendieckTopology.isIso_toSheafify
File: Mathlib/CategoryTheory/Sites/Sheafification.lean

tactic: dsimp [toSheafify]
state_before: C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P : Cᵒᵖ ⥤ D
hP : Presheaf.IsSheaf J P
⊢ IsIso (toSheafify J P)

tactic: haveI := isIso_toPlus_of_isSheaf J P hP
state_before: C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P : Cᵒᵖ ⥤ D
hP : Presheaf.IsSheaf J P
⊢ IsIso (toPlus J P ≫ plusMap J (toPlus J P))

tactic: change (IsIso (toPlus J P ≫ (J.plusFunctor D).map (toPlus J P)))
state_before: C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P : Cᵒᵖ ⥤ D
hP : Presheaf.IsSheaf J P
this : IsIso (toPlus J P)
⊢ IsIso (toPlus J P ≫ plusMap J (toPlus J P))

tactic: infer_instance
state_before: C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P : Cᵒᵖ ⥤ D
hP : Presheaf.IsSheaf J P
this : IsIso (toPlus J P)
⊢ IsIso (toPlus J P ≫ (plusFunctor J D).map (toPlus J P))
Theorem: WithBot.unbot'_eq_iff
File: Mathlib/Order/WithBot.lean

tactic: induction x using recBotCoe <;> simp [@eq_comm _ d]
state_before: α : Type u_1
β : Type ?u.3913
γ : Type ?u.3916
δ : Type ?u.3919
a b d y : α
x : WithBot α
⊢ unbot' d x = y ↔ x = ↑y ∨ x = ⊥ ∧ y = d