tasksource/leandojo huggingface dataset:
Theorem: String.Iterator.Valid.remainingBytes_le
File: Std/Data/String/Lemmas.lean

tactic: simp [h.remainingBytes, h.toString, Nat.le_add_left]
state_before: x✝ : Iterator
h✝ : Valid x✝
l r : List Char
h : ValidFor l r x✝
⊢ remainingBytes x✝ ≤ utf8ByteSize x✝.s
Theorem: bound'_sq
File: Mathlib/NumberTheory/Padics/Hensel.lean

tactic: rw [← MulZeroClass.mul_zero ‖F.derivative.eval a‖, sq]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
⊢ Tendsto (fun n => ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2 * T_gen p F a ^ 2 ^ n) atTop (𝓝 0)

tactic: simp only [mul_assoc]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
⊢ Tendsto
    (fun n =>
      ‖Polynomial.eval a (↑Polynomial.derivative F)‖ * ‖Polynomial.eval a (↑Polynomial.derivative F)‖ *
        T_gen p F a ^ 2 ^ n)
    atTop (𝓝 (‖Polynomial.eval a (↑Polynomial.derivative F)‖ * 0))

tactic: apply Tendsto.mul
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
⊢ Tendsto
    (fun n =>
      ‖Polynomial.eval a (↑Polynomial.derivative F)‖ *
        (‖Polynomial.eval a (↑Polynomial.derivative F)‖ * T_gen p F a ^ 2 ^ n))
    atTop (𝓝 (‖Polynomial.eval a (↑Polynomial.derivative F)‖ * 0))

tactic: apply tendsto_const_nhds
state_before: case hf
p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
⊢ Tendsto (fun x => ‖Polynomial.eval a (↑Polynomial.derivative F)‖) atTop
    (𝓝 ‖Polynomial.eval a (↑Polynomial.derivative F)‖)

tactic: apply bound'
state_before: case hg
p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
⊢ Tendsto (fun x => ‖Polynomial.eval a (↑Polynomial.derivative F)‖ * T_gen p F a ^ 2 ^ x) atTop (𝓝 0)

tactic: assumption
state_before: case hg.hnorm
p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
⊢ ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
Theorem: List.Lex.cons_iff
File: Mathlib/Data/List/Lex.lean

tactic: cases' h with _ _ _ _ _ h _ _ _ _ h
state_before: α : Type u
r : α → α → Prop
inst✝ : IsIrrefl α r
a : α
l₁ l₂ : List α
h : Lex r (a :: l₁) (a :: l₂)
⊢ Lex r l₁ l₂

tactic: exacts [h, (irrefl_of r a h).elim]
state_before: case cons
α : Type u
r : α → α → Prop
inst✝ : IsIrrefl α r
a : α
l₁ l₂ : List α
h : Lex r l₁ l₂
⊢ Lex r l₁ l₂

case rel
α : Type u
r : α → α → Prop
inst✝ : IsIrrefl α r
a : α
l₁ l₂ : List α
h : r a a
⊢ Lex r l₁ l₂
Theorem: Mathlib.Tactic.Ring.single_pow
File: Mathlib/Tactic/Ring/Basic.lean

tactic: simp [*]
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a : R
b : ℕ
c : R
x✝ : a ^ b = c
⊢ (a + 0) ^ b = c + 0
Theorem: MeasureTheory.stronglyMeasurable_const'
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

tactic: cases' isEmpty_or_nonempty α with _ h
state_before: α✝ : Type ?u.15025
β✝ : Type ?u.15028
γ : Type ?u.15031
ι : Type ?u.15034
inst✝¹ : Countable ι
α : Type u_1
β : Type u_2
m : MeasurableSpace α
inst✝ : TopologicalSpace β
f : α → β
hf : ∀ (x y : α), f x = f y
⊢ StronglyMeasurable f

tactic: exact stronglyMeasurable_of_isEmpty f
state_before: case inl
α✝ : Type ?u.15025
β✝ : Type ?u.15028
γ : Type ?u.15031
ι : Type ?u.15034
inst✝¹ : Countable ι
α : Type u_1
β : Type u_2
m : MeasurableSpace α
inst✝ : TopologicalSpace β
f : α → β
hf : ∀ (x y : α), f x = f y
h✝ : IsEmpty α
⊢ StronglyMeasurable f

tactic: convert stronglyMeasurable_const (β := β) using 1
state_before: case inr
α✝ : Type ?u.15025
β✝ : Type ?u.15028
γ : Type ?u.15031
ι : Type ?u.15034
inst✝¹ : Countable ι
α : Type u_1
β : Type u_2
m : MeasurableSpace α
inst✝ : TopologicalSpace β
f : α → β
hf : ∀ (x y : α), f x = f y
h : Nonempty α
⊢ StronglyMeasurable f

tactic: exact funext fun x => hf x h.some
state_before: case h.e'_5
α✝ : Type ?u.15025
β✝ : Type ?u.15028
γ : Type ?u.15031
ι : Type ?u.15034
inst✝¹ : Countable ι
α : Type u_1
β : Type u_2
m : MeasurableSpace α
inst✝ : TopologicalSpace β
f : α → β
hf : ∀ (x y : α), f x = f y
h : Nonempty α
⊢ f = fun x => ?inr.convert_3

case inr.convert_3
α✝ : Type ?u.15025
β✝ : Type ?u.15028
γ : Type ?u.15031
ι : Type ?u.15034
inst✝¹ : Countable ι
α : Type u_1
β : Type u_2
m : MeasurableSpace α
inst✝ : TopologicalSpace β
f : α → β
hf : ∀ (x y : α), f x = f y
h : Nonempty α
⊢ β
Theorem: convexJoin_singleton_left
File: Mathlib/Analysis/Convex/Join.lean

tactic: simp [convexJoin]
state_before: ι : Sort ?u.20440
𝕜 : Type u_2
E : Type u_1
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : Module 𝕜 E
s t✝ s₁ s₂ t₁ t₂ u : Set E
x✝ y : E
t : Set E
x : E
⊢ convexJoin 𝕜 {x} t = ⋃ (y : E) (_ : y ∈ t), segment 𝕜 x y
Theorem: closure_iUnion
File: Mathlib/Topology/Basic.lean

tactic: cases nonempty_fintype ι
state_before: α : Type u
β : Type v
ι✝ : Sort w
a : α
s s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝¹ : TopologicalSpace α
ι : Type u_1
inst✝ : Finite ι
f : ι → Set α
⊢ closure (⋃ (i : ι), f i) = ⋃ (i : ι), closure (f i)

tactic: convert Finset.univ.closure_biUnion f <;> simp
state_before: case intro
α : Type u
β : Type v
ι✝ : Sort w
a : α
s s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝¹ : TopologicalSpace α
ι : Type u_1
inst✝ : Finite ι
f : ι → Set α
val✝ : Fintype ι
⊢ closure (⋃ (i : ι), f i) = ⋃ (i : ι), closure (f i)
Theorem: Nat.odd_sub
File: Mathlib/Data/Nat/Parity.lean

tactic: rw [odd_iff_not_even, even_sub h, not_iff, odd_iff_not_even]
state_before: m n : ℕ
h : n ≤ m
⊢ Odd (m - n) ↔ (Odd m ↔ Even n)
Theorem: Multiset.coe_join
File: Mathlib/Data/Multiset/Bind.lean

tactic: simp only [join, List.map, coe_sum, List.sum_cons, List.join, ←coe_add, ←coe_join L]
state_before: α : Type u_1
β : Type ?u.238
γ : Type ?u.241
δ : Type ?u.244
l : List α
L : List (List α)
⊢ join ↑(List.map ofList (l :: L)) = ↑(List.join (l :: L))
Theorem: SemidirectProduct.rightHom_inl
File: Mathlib/GroupTheory/SemidirectProduct.lean

tactic: simp [rightHom]
state_before: N : Type u_2
G : Type u_1
H : Type ?u.113527
inst✝² : Group N
inst✝¹ : Group G
inst✝ : Group H
φ : G →* MulAut N
n : N
⊢ ↑rightHom (↑inl n) = 1
Theorem: Int.image_fract
File: Mathlib/Algebra/Order/Floor.lean

tactic: ext x
state_before: F : Type ?u.180856
α : Type u_1
β : Type ?u.180862
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
s : Set α
⊢ fract '' s = ⋃ (m : ℤ), (fun x => x - ↑m) '' s ∩ Ico 0 1

tactic: simp only [mem_image, mem_inter_iff, mem_iUnion]
state_before: case h
F : Type ?u.180856
α : Type u_1
β : Type ?u.180862
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
s : Set α
x : α
⊢ x ∈ fract '' s ↔ x ∈ ⋃ (m : ℤ), (fun x => x - ↑m) '' s ∩ Ico 0 1

tactic: constructor
state_before: case h
F : Type ?u.180856
α : Type u_1
β : Type ?u.180862
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
s : Set α
x : α
⊢ (∃ x_1, x_1 ∈ s ∧ fract x_1 = x) ↔ ∃ i, (∃ x_1, x_1 ∈ s ∧ x_1 - ↑i = x) ∧ x ∈ Ico 0 1

tactic: rintro ⟨y, hy, rfl⟩
state_before: case h.mp
F : Type ?u.180856
α : Type u_1
β : Type ?u.180862
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
s : Set α
x : α
⊢ (∃ x_1, x_1 ∈ s ∧ fract x_1 = x) → ∃ i, (∃ x_1, x_1 ∈ s ∧ x_1 - ↑i = x) ∧ x ∈ Ico 0 1

tactic: exact ⟨⌊y⌋, ⟨y, hy, rfl⟩, fract_nonneg y, fract_lt_one y⟩
state_before: case h.mp.intro.intro
F : Type ?u.180856
α : Type u_1
β : Type ?u.180862
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
s : Set α
y : α
hy : y ∈ s
⊢ ∃ i, (∃ x, x ∈ s ∧ x - ↑i = fract y) ∧ fract y ∈ Ico 0 1

tactic: rintro ⟨m, ⟨y, hys, rfl⟩, h0, h1⟩
state_before: case h.mpr
F : Type ?u.180856
α : Type u_1
β : Type ?u.180862
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
s : Set α
x : α
⊢ (∃ i, (∃ x_1, x_1 ∈ s ∧ x_1 - ↑i = x) ∧ x ∈ Ico 0 1) → ∃ x_1, x_1 ∈ s ∧ fract x_1 = x

tactic: obtain rfl : ⌊y⌋ = m := floor_eq_iff.2 ⟨sub_nonneg.1 h0, sub_lt_iff_lt_add'.1 h1⟩
state_before: case h.mpr.intro.intro.intro.intro.intro
F : Type ?u.180856
α : Type u_1
β : Type ?u.180862
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
s : Set α
m : ℤ
y : α
hys : y ∈ s
h0 : 0 ≤ y - ↑m
h1 : y - ↑m < 1
⊢ ∃ x, x ∈ s ∧ fract x = y - ↑m

tactic: exact ⟨y, hys, rfl⟩
state_before: case h.mpr.intro.intro.intro.intro.intro
F : Type ?u.180856
α : Type u_1
β : Type ?u.180862
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
s : Set α
y : α
hys : y ∈ s
h0 : 0 ≤ y - ↑⌊y⌋
h1 : y - ↑⌊y⌋ < 1
⊢ ∃ x, x ∈ s ∧ fract x = y - ↑⌊y⌋
Theorem: Num.gcd_to_nat
File: Mathlib/Data/Num/Lemmas.lean

tactic: have : ∀ a b : Num, (a * b).natSize ≤ a.natSize + b.natSize := by
  intros
  simp [natSize_to_nat]
  rw [Nat.size_le, pow_add]
  exact mul_lt_mul'' (Nat.lt_size_self _) (Nat.lt_size_self _) (Nat.zero_le _) (Nat.zero_le _)
state_before: ⊢ ∀ (a b : Num), ↑(gcd a b) = Nat.gcd ↑a ↑b

tactic: intros
state_before: this : ∀ (a b : Num), natSize (a * b) ≤ natSize a + natSize b
⊢ ∀ (a b : Num), ↑(gcd a b) = Nat.gcd ↑a ↑b

tactic: unfold gcd
state_before: this : ∀ (a b : Num), natSize (a * b) ≤ natSize a + natSize b
a✝ b✝ : Num
⊢ ↑(gcd a✝ b✝) = Nat.gcd ↑a✝ ↑b✝

tactic: split_ifs with h
state_before: this : ∀ (a b : Num), natSize (a * b) ≤ natSize a + natSize b
a✝ b✝ : Num
⊢ ↑(if a✝ ≤ b✝ then gcdAux (natSize a✝ + natSize b✝) a✝ b✝ else gcdAux (natSize b✝ + natSize a✝) b✝ a✝) =
    Nat.gcd ↑a✝ ↑b✝

tactic: intros
state_before: ⊢ ∀ (a b : Num), natSize (a * b) ≤ natSize a + natSize b

tactic: simp [natSize_to_nat]
state_before: a✝ b✝ : Num
⊢ natSize (a✝ * b✝) ≤ natSize a✝ + natSize b✝

tactic: rw [Nat.size_le, pow_add]
state_before: a✝ b✝ : Num
⊢ Nat.size (↑a✝ * ↑b✝) ≤ Nat.size ↑a✝ + Nat.size ↑b✝

tactic: exact mul_lt_mul'' (Nat.lt_size_self _) (Nat.lt_size_self _) (Nat.zero_le _) (Nat.zero_le _)
state_before: a✝ b✝ : Num
⊢ ↑a✝ * ↑b✝ < 2 ^ Nat.size ↑a✝ * 2 ^ Nat.size ↑b✝

tactic: exact gcd_to_nat_aux h (this _ _)
state_before: case inl
this : ∀ (a b : Num), natSize (a * b) ≤ natSize a + natSize b
a✝ b✝ : Num
h : a✝ ≤ b✝
⊢ ↑(gcdAux (natSize a✝ + natSize b✝) a✝ b✝) = Nat.gcd ↑a✝ ↑b✝

tactic: rw [Nat.gcd_comm]
state_before: case inr
this : ∀ (a b : Num), natSize (a * b) ≤ natSize a + natSize b
a✝ b✝ : Num
h : ¬a✝ ≤ b✝
⊢ ↑(gcdAux (natSize b✝ + natSize a✝) b✝ a✝) = Nat.gcd ↑a✝ ↑b✝

tactic: exact gcd_to_nat_aux (le_of_not_le h) (this _ _)
state_before: case inr
this : ∀ (a b : Num), natSize (a * b) ≤ natSize a + natSize b
a✝ b✝ : Num
h : ¬a✝ ≤ b✝
⊢ ↑(gcdAux (natSize b✝ + natSize a✝) b✝ a✝) = Nat.gcd ↑b✝ ↑a✝
Theorem: WittVector.constantCoeff_wittNSMul
File: Mathlib/RingTheory/WittVector/Defs.lean

tactic: apply constantCoeff_wittStructureInt p _ _ n
state_before: p : ℕ
R : Type ?u.168255
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
m n : ℕ
⊢ ↑constantCoeff (wittNSMul p m n) = 0

tactic: simp only [smul_zero, map_nsmul, constantCoeff_X]
state_before: p : ℕ
R : Type ?u.168255
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
m n : ℕ
⊢ ↑constantCoeff (m • X 0) = 0
Theorem: mul_self_inj_of_nonneg
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: subst a
state_before: ι : Type ?u.197416
α : Type u_1
β : Type ?u.197422
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
a0 : 0 ≤ a
b0 : 0 ≤ b
h : a = -b
⊢ a = b

tactic: have : b = 0 := le_antisymm (neg_nonneg.1 a0) b0
state_before: ι : Type ?u.197416
α : Type u_1
β : Type ?u.197422
inst✝ : LinearOrderedField α
b c d : α
n : ℤ
b0 : 0 ≤ b
a0 : 0 ≤ -b
⊢ -b = b

tactic: rw [this, neg_zero]
state_before: ι : Type ?u.197416
α : Type u_1
β : Type ?u.197422
inst✝ : LinearOrderedField α
b c d : α
n : ℤ
b0 : 0 ≤ b
a0 : 0 ≤ -b
this : b = 0
⊢ -b = b
Theorem: isConj_iff_conjugatesOf_eq
File: Mathlib/Algebra/Group/Conj.lean

tactic: have ha := @mem_conjugatesOf_self _ _ b
state_before: α : Type u
β : Type v
inst✝ : Monoid α
a b : α
h : conjugatesOf a = conjugatesOf b
⊢ IsConj a b

tactic: rwa [← h] at ha
state_before: α : Type u
β : Type v
inst✝ : Monoid α
a b : α
h : conjugatesOf a = conjugatesOf b
ha : b ∈ conjugatesOf b
⊢ IsConj a b
Theorem: Finsupp.support_mul
File: Mathlib/Data/Finsupp/Pointwise.lean

tactic: intro a h
state_before: α : Type u₁
β : Type u₂
γ : Type u₃
δ : Type u₄
ι : Type u₅
inst✝¹ : MulZeroClass β
inst✝ : DecidableEq α
g₁ g₂ : α →₀ β
⊢ (g₁ * g₂).support ⊆ g₁.support ∩ g₂.support

tactic: simp only [mul_apply, mem_support_iff] at h
state_before: α : Type u₁
β : Type u₂
γ : Type u₃
δ : Type u₄
ι : Type u₅
inst✝¹ : MulZeroClass β
inst✝ : DecidableEq α
g₁ g₂ : α →₀ β
a : α
h : a ∈ (g₁ * g₂).support
⊢ a ∈ g₁.support ∩ g₂.support

tactic: simp only [mem_support_iff, mem_inter, Ne.def]
state_before: α : Type u₁
β : Type u₂
γ : Type u₃
δ : Type u₄
ι : Type u₅
inst✝¹ : MulZeroClass β
inst✝ : DecidableEq α
g₁ g₂ : α →₀ β
a : α
h : ↑g₁ a * ↑g₂ a ≠ 0
⊢ a ∈ g₁.support ∩ g₂.support

tactic: rw [← not_or]
state_before: α : Type u₁
β : Type u₂
γ : Type u₃
δ : Type u₄
ι : Type u₅
inst✝¹ : MulZeroClass β
inst✝ : DecidableEq α
g₁ g₂ : α →₀ β
a : α
h : ↑g₁ a * ↑g₂ a ≠ 0
⊢ ¬↑g₁ a = 0 ∧ ¬↑g₂ a = 0

tactic: intro w
state_before: α : Type u₁
β : Type u₂
γ : Type u₃
δ : Type u₄
ι : Type u₅
inst✝¹ : MulZeroClass β
inst✝ : DecidableEq α
g₁ g₂ : α →₀ β
a : α
h : ↑g₁ a * ↑g₂ a ≠ 0
⊢ ¬(↑g₁ a = 0 ∨ ↑g₂ a = 0)

tactic: apply h
state_before: α : Type u₁
β : Type u₂
γ : Type u₃
δ : Type u₄
ι : Type u₅
inst✝¹ : MulZeroClass β
inst✝ : DecidableEq α
g₁ g₂ : α →₀ β
a : α
h : ↑g₁ a * ↑g₂ a ≠ 0
w : ↑g₁ a = 0 ∨ ↑g₂ a = 0
⊢ False

tactic: cases' w with w w <;> (rw [w] ; simp)
state_before: α : Type u₁
β : Type u₂
γ : Type u₃
δ : Type u₄
ι : Type u₅
inst✝¹ : MulZeroClass β
inst✝ : DecidableEq α
g₁ g₂ : α →₀ β
a : α
h : ↑g₁ a * ↑g₂ a ≠ 0
w : ↑g₁ a = 0 ∨ ↑g₂ a = 0
⊢ ↑g₁ a * ↑g₂ a = 0

tactic: rw [w]
state_before: case inr
α : Type u₁
β : Type u₂
γ : Type u₃
δ : Type u₄
ι : Type u₅
inst✝¹ : MulZeroClass β
inst✝ : DecidableEq α
g₁ g₂ : α →₀ β
a : α
h : ↑g₁ a * ↑g₂ a ≠ 0
w : ↑g₂ a = 0
⊢ ↑g₁ a * ↑g₂ a = 0

tactic: simp
state_before: case inr
α : Type u₁
β : Type u₂
γ : Type u₃
δ : Type u₄
ι : Type u₅
inst✝¹ : MulZeroClass β
inst✝ : DecidableEq α
g₁ g₂ : α →₀ β
a : α
h : ↑g₁ a * ↑g₂ a ≠ 0
w : ↑g₂ a = 0
⊢ ↑g₁ a * 0 = 0
Theorem: EuclideanDomain.lt_one
File: Mathlib/Algebra/EuclideanDomain/Defs.lean

tactic: simpa only [one_mul] using mul_left_not_lt 1 h
state_before: R : Type u
inst✝ : EuclideanDomain R
a : R
this : (p : Prop) → Decidable p
h : ¬a = 0
⊢ ¬a ≺ 1
Theorem: char_prime_of_ne_zero
File: Mathlib/Algebra/CharP/ExpChar.lean

tactic: cases' CharP.char_is_prime_or_zero R p with h h
state_before: R : Type u
inst✝² : Semiring R
inst✝¹ : Nontrivial R
inst✝ : NoZeroDivisors R
p : ℕ
hp : CharP R p
p_ne_zero : p ≠ 0
⊢ Nat.Prime p

tactic: exact h
state_before: case inl
R : Type u
inst✝² : Semiring R
inst✝¹ : Nontrivial R
inst✝ : NoZeroDivisors R
p : ℕ
hp : CharP R p
p_ne_zero : p ≠ 0
h : Nat.Prime p
⊢ Nat.Prime p

tactic: contradiction
state_before: case inr
R : Type u
inst✝² : Semiring R
inst✝¹ : Nontrivial R
inst✝ : NoZeroDivisors R
p : ℕ
hp : CharP R p
p_ne_zero : p ≠ 0
h : p = 0
⊢ Nat.Prime p
Theorem: Dfinsupp.zipWith_neLocus_eq_right
File: Mathlib/Data/Dfinsupp/NeLocus.lean

tactic: ext a
state_before: α : Type u_4
N : α → Type u_3
inst✝⁵ : DecidableEq α
M : α → Type u_1
P : α → Type u_2
inst✝⁴ : (a : α) → Zero (N a)
inst✝³ : (a : α) → Zero (M a)
inst✝² : (a : α) → Zero (P a)
inst✝¹ : (a : α) → DecidableEq (M a)
inst✝ : (a : α) → DecidableEq (P a)
F : (a : α) → M a → N a → P a
F0 : ∀ (a : α), F a 0 0 = 0
f₁ f₂ : Π₀ (a : α), M a
g : Π₀ (a : α), N a
hF : ∀ (a : α) (g : N a), Function.Injective fun f => F a f g
⊢ neLocus (zipWith F F0 f₁ g) (zipWith F F0 f₂ g) = neLocus f₁ f₂

tactic: simpa only [mem_neLocus] using (hF a _).ne_iff
state_before: case a
α : Type u_4
N : α → Type u_3
inst✝⁵ : DecidableEq α
M : α → Type u_1
P : α → Type u_2
inst✝⁴ : (a : α) → Zero (N a)
inst✝³ : (a : α) → Zero (M a)
inst✝² : (a : α) → Zero (P a)
inst✝¹ : (a : α) → DecidableEq (M a)
inst✝ : (a : α) → DecidableEq (P a)
F : (a : α) → M a → N a → P a
F0 : ∀ (a : α), F a 0 0 = 0
f₁ f₂ : Π₀ (a : α), M a
g : Π₀ (a : α), N a
hF : ∀ (a : α) (g : N a), Function.Injective fun f => F a f g
a : α
⊢ a ∈ neLocus (zipWith F F0 f₁ g) (zipWith F F0 f₂ g) ↔ a ∈ neLocus f₁ f₂
Theorem: CategoryTheory.Functor.IsMittagLeffler.subset_image_eventualRange
File: Mathlib/CategoryTheory/CofilteredSystem.lean

tactic: obtain ⟨k, g, hg⟩ := F.isMittagLeffler_iff_eventualRange.1 h j
state_before: J : Type u
inst✝ : Category J
F : J ⥤ Type v
i j k : J
s : Set (F.obj i)
h : IsMittagLeffler F
f : j ⟶ i
⊢ eventualRange F i ⊆ F.map f '' eventualRange F j

tactic: rw [hg]
state_before: case intro.intro
J : Type u
inst✝ : Category J
F : J ⥤ Type v
i j k✝ : J
s : Set (F.obj i)
h : IsMittagLeffler F
f : j ⟶ i
k : J
g : k ⟶ j
hg : eventualRange F j = range (F.map g)
⊢ eventualRange F i ⊆ F.map f '' eventualRange F j

tactic: intro x hx
state_before: case intro.intro
J : Type u
inst✝ : Category J
F : J ⥤ Type v
i j k✝ : J
s : Set (F.obj i)
h : IsMittagLeffler F
f : j ⟶ i
k : J
g : k ⟶ j
hg : eventualRange F j = range (F.map g)
⊢ eventualRange F i ⊆ F.map f '' range (F.map g)

tactic: obtain ⟨x, rfl⟩ := F.mem_eventualRange_iff.1 hx (g ≫ f)
state_before: case intro.intro
J : Type u
inst✝ : Category J
F : J ⥤ Type v
i j k✝ : J
s : Set (F.obj i)
h : IsMittagLeffler F
f : j ⟶ i
k : J
g : k ⟶ j
hg : eventualRange F j = range (F.map g)
x : F.obj i
hx : x ∈ eventualRange F i
⊢ x ∈ F.map f '' range (F.map g)

tactic: refine' ⟨_, ⟨x, rfl⟩, by rw [map_comp_apply] ⟩
state_before: case intro.intro.intro
J : Type u
inst✝ : Category J
F : J ⥤ Type v
i j k✝ : J
s : Set (F.obj i)
h : IsMittagLeffler F
f : j ⟶ i
k : J
g : k ⟶ j
hg : eventualRange F j = range (F.map g)
x : F.obj k
hx : F.map (g ≫ f) x ∈ eventualRange F i
⊢ F.map (g ≫ f) x ∈ F.map f '' range (F.map g)

tactic: rw [map_comp_apply]
state_before: J : Type u
inst✝ : Category J
F : J ⥤ Type v
i j k✝ : J
s : Set (F.obj i)
h : IsMittagLeffler F
f : j ⟶ i
k : J
g : k ⟶ j
hg : eventualRange F j = range (F.map g)
x : F.obj k
hx : F.map (g ≫ f) x ∈ eventualRange F i
⊢ F.map f (F.map g x) = F.map (g ≫ f) x
Theorem: Relation.transGen_eq_self
File: Mathlib/Logic/Relation.lean

tactic: induction h
state_before: α : Type u_1
β : Type ?u.22591
γ : Type ?u.22594
δ : Type ?u.22597
r : α → α → Prop
a✝ b✝ c d : α
trans : Transitive r
a b : α
h : TransGen r a b
⊢ r a b

tactic: case single _ hc => exact hc
state_before: case single
α : Type u_1
β : Type ?u.22591
γ : Type ?u.22594
δ : Type ?u.22597
r : α → α → Prop
a✝¹ b✝¹ c d : α
trans : Transitive r
a b b✝ : α
a✝ : r a b✝
⊢ r a b✝

case tail
α : Type u_1
β : Type ?u.22591
γ : Type ?u.22594
δ : Type ?u.22597
r : α → α → Prop
a✝² b✝¹ c d : α
trans : Transitive r
a b b✝ c✝ : α
a✝¹ : TransGen r a b✝
a✝ : r b✝ c✝
a_ih✝ : r a b✝
⊢ r a c✝

tactic: case tail c d _ hcd hac => exact trans hac hcd
state_before: case tail
α : Type u_1
β : Type ?u.22591
γ : Type ?u.22594
δ : Type ?u.22597
r : α → α → Prop
a✝² b✝¹ c d : α
trans : Transitive r
a b b✝ c✝ : α
a✝¹ : TransGen r a b✝
a✝ : r b✝ c✝
a_ih✝ : r a b✝
⊢ r a c✝

tactic: exact hc
state_before: α : Type u_1
β : Type ?u.22591
γ : Type ?u.22594
δ : Type ?u.22597
r : α → α → Prop
a✝ b✝¹ c d : α
trans : Transitive r
a b b✝ : α
hc : r a b✝
⊢ r a b✝

tactic: exact trans hac hcd
state_before: α : Type u_1
β : Type ?u.22591
γ : Type ?u.22594
δ : Type ?u.22597
r : α → α → Prop
a✝¹ b✝ c✝ d✝ : α
trans : Transitive r
a b c d : α
a✝ : TransGen r a c
hcd : r c d
hac : r a c
⊢ r a d
Theorem: Real.smul_map_volume_mul_right
File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

tactic: simpa only [mul_comm] using Real.smul_map_volume_mul_left h
state_before: ι : Type ?u.2207770
inst✝ : Fintype ι
a : ℝ
h : a ≠ 0
⊢ ofReal (abs a) • Measure.map (fun x => x * a) volume = volume
Theorem: Nat.factorization_mul_support_of_coprime
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: rw [factorization_mul_of_coprime hab]
state_before: a b : ℕ
hab : coprime a b
⊢ (factorization (a * b)).support = (factorization a).support ∪ (factorization b).support

tactic: exact support_add_eq (factorization_disjoint_of_coprime hab)
state_before: a b : ℕ
hab : coprime a b
⊢ (factorization a + factorization b).support = (factorization a).support ∪ (factorization b).support
Theorem: IsBoundedLinearMap.neg
File: Mathlib/Analysis/NormedSpace/BoundedLinearMaps.lean

tactic: rw [show (fun e => -f e) = fun e => (-1 : 𝕜) • f e by funext; simp]
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type u_3
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type ?u.41770
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
hf : IsBoundedLinearMap 𝕜 f
⊢ IsBoundedLinearMap 𝕜 fun e => -f e

tactic: exact smul (-1) hf
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type u_3
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type ?u.41770
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
hf : IsBoundedLinearMap 𝕜 f
⊢ IsBoundedLinearMap 𝕜 fun e => -1 • f e

tactic: funext
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type u_3
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type ?u.41770
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
hf : IsBoundedLinearMap 𝕜 f
⊢ (fun e => -f e) = fun e => -1 • f e

tactic: simp
state_before: case h
𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type u_3
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type ?u.41770
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
hf : IsBoundedLinearMap 𝕜 f
x✝ : E
⊢ -f x✝ = -1 • f x✝
Theorem: Real.sinh_sub_id_strictMono
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean

tactic: refine' strictMono_of_odd_strictMonoOn_nonneg (fun x => by simp; abel) _
state_before: x y z : ℝ
⊢ StrictMono fun x => sinh x - x

tactic: refine' (convex_Ici _).strictMonoOn_of_deriv_pos _ fun x hx => _
state_before: x y z : ℝ
⊢ StrictMonoOn (fun x => sinh x - x) (Ici 0)

tactic: simp
state_before: x✝ y z x : ℝ
⊢ sinh (-x) - -x = -(sinh x - x)

tactic: abel
state_before: x✝ y z x : ℝ
⊢ -sinh x + x = x - sinh x

tactic: exact (continuous_sinh.sub continuous_id).continuousOn
state_before: case refine'_1
x y z : ℝ
⊢ ContinuousOn (fun x => sinh x - x) (Ici 0)

tactic: rw [interior_Ici, mem_Ioi] at hx
state_before: case refine'_2
x✝ y z x : ℝ
hx : x ∈ interior (Ici 0)
⊢ 0 < deriv (fun x => sinh x - x) x

tactic: rw [deriv_sub, deriv_sinh, deriv_id'', sub_pos, one_lt_cosh]
state_before: case refine'_2
x✝ y z x : ℝ
hx : 0 < x
⊢ 0 < deriv (fun x => sinh x - x) x

tactic: exacts [hx.ne', differentiableAt_sinh, differentiableAt_id]
state_before: case refine'_2
x✝ y z x : ℝ
hx : 0 < x
⊢ x ≠ 0

case refine'_2.hf
x✝ y z x : ℝ
hx : 0 < x
⊢ DifferentiableAt ℝ (fun x => sinh x) x

case refine'_2.hg
x✝ y z x : ℝ
hx : 0 < x
⊢ DifferentiableAt ℝ (fun x => x) x
Theorem: xor_self
File: Mathlib/Logic/Basic.lean

tactic: simp [Xor']
state_before: a : Prop
⊢ Xor' a a = False
Theorem: Dfinsupp.update_self
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: ext
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → Zero (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i : ι
f : Π₀ (i : ι), β i
b : β i
j : ι
⊢ update i f (↑f i) = f

tactic: simp
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → Zero (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i : ι
f : Π₀ (i : ι), β i
b : β i
j i✝ : ι
⊢ ↑(update i f (↑f i)) i✝ = ↑f i✝