tasksource/leandojo huggingface dataset:
Theorem: Ideal.minimalPrimes_eq_subsingleton
File: Mathlib/RingTheory/Ideal/MinimalPrime.lean

tactic: ext J
state_before: R : Type u_1
S : Type ?u.121108
inst✝¹ : CommRing R
inst✝ : CommRing S
I J : Ideal R
hI : IsPrimary I
⊢ Ideal.minimalPrimes I = {radical I}

tactic: constructor
state_before: case h
R : Type u_1
S : Type ?u.121108
inst✝¹ : CommRing R
inst✝ : CommRing S
I J✝ : Ideal R
hI : IsPrimary I
J : Ideal R
⊢ J ∈ Ideal.minimalPrimes I ↔ J ∈ {radical I}

tactic: exact fun H =>
  let e := H.1.1.radical_le_iff.mpr H.1.2
  (H.2 ⟨Ideal.isPrime_radical hI, Ideal.le_radical⟩ e).antisymm e
state_before: case h.mp
R : Type u_1
S : Type ?u.121108
inst✝¹ : CommRing R
inst✝ : CommRing S
I J✝ : Ideal R
hI : IsPrimary I
J : Ideal R
⊢ J ∈ Ideal.minimalPrimes I → J ∈ {radical I}

tactic: rintro (rfl : J = I.radical)
state_before: case h.mpr
R : Type u_1
S : Type ?u.121108
inst✝¹ : CommRing R
inst✝ : CommRing S
I J✝ : Ideal R
hI : IsPrimary I
J : Ideal R
⊢ J ∈ {radical I} → J ∈ Ideal.minimalPrimes I

tactic: exact ⟨⟨Ideal.isPrime_radical hI, Ideal.le_radical⟩, fun _ H _ => H.1.radical_le_iff.mpr H.2⟩
state_before: case h.mpr
R : Type u_1
S : Type ?u.121108
inst✝¹ : CommRing R
inst✝ : CommRing S
I J : Ideal R
hI : IsPrimary I
⊢ radical I ∈ Ideal.minimalPrimes I
Theorem: MeasureTheory.L2.add_left'
File: Mathlib/MeasureTheory/Function/L2Space.lean

tactic: simp_rw [inner_def, ← integral_add (integrable_inner f g) (integrable_inner f' g), ←
  inner_add_left]
state_before: α : Type u_1
E : Type u_2
F : Type ?u.99640
𝕜 : Type u_3
inst✝⁴ : IsROrC 𝕜
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : NormedAddCommGroup F
f f' g : { x // x ∈ Lp E 2 }
⊢ inner (f + f') g = inner f g + inner f' g

tactic: refine' integral_congr_ae ((coeFn_add f f').mono fun x hx => _)
state_before: α : Type u_1
E : Type u_2
F : Type ?u.99640
𝕜 : Type u_3
inst✝⁴ : IsROrC 𝕜
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : NormedAddCommGroup F
f f' g : { x // x ∈ Lp E 2 }
⊢ (∫ (a : α), inner (↑↑(f + f') a) (↑↑g a) ∂μ) = ∫ (a : α), inner (↑↑f a + ↑↑f' a) (↑↑g a) ∂μ

tactic: simp only
state_before: α : Type u_1
E : Type u_2
F : Type ?u.99640
𝕜 : Type u_3
inst✝⁴ : IsROrC 𝕜
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : NormedAddCommGroup F
f f' g : { x // x ∈ Lp E 2 }
x : α
hx : ↑↑(f + f') x = (↑↑f + ↑↑f') x
⊢ (fun a => inner (↑↑(f + f') a) (↑↑g a)) x = (fun a => inner (↑↑f a + ↑↑f' a) (↑↑g a)) x

tactic: rw [hx, Pi.add_apply]
state_before: α : Type u_1
E : Type u_2
F : Type ?u.99640
𝕜 : Type u_3
inst✝⁴ : IsROrC 𝕜
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : NormedAddCommGroup F
f f' g : { x // x ∈ Lp E 2 }
x : α
hx : ↑↑(f + f') x = (↑↑f + ↑↑f') x
⊢ inner (↑↑(f + f') x) (↑↑g x) = inner (↑↑f x + ↑↑f' x) (↑↑g x)
Theorem: Polynomial.toLaurent_C_mul_T
File: Mathlib/Data/Polynomial/Laurent.lean

tactic: rw [toFinsupp_monomial, Finsupp.mapDomain_single, single_eq_C_mul_T]
state_before: R : Type u_1
inst✝ : Semiring R
n : ℕ
r : R
⊢ Finsupp.mapDomain Nat.cast (↑(monomial n) r).toFinsupp = ↑C r * T ↑n
Theorem: Std.BinomialHeapImp.Heap.WellFormed.tail?
File: Std/Data/BinomialHeap.lean

tactic: simp only [Heap.tail?]
state_before: α : Type u_1
s : Heap α
le : α → α → Bool
n : Nat
tl : Heap α
hwf : WellFormed le n s
⊢ Heap.tail? le s = some tl → WellFormed le 0 tl

tactic: intro eq
state_before: α : Type u_1
s : Heap α
le : α → α → Bool
n : Nat
tl : Heap α
hwf : WellFormed le n s
⊢ Option.map (fun x => x.snd) (Heap.deleteMin le s) = some tl → WellFormed le 0 tl

tactic: match eq₂ : s.deleteMin le, eq with
| some (a, tl), rfl => exact hwf.deleteMin eq₂
state_before: α : Type u_1
s : Heap α
le : α → α → Bool
n : Nat
tl : Heap α
hwf : WellFormed le n s
eq : Option.map (fun x => x.snd) (Heap.deleteMin le s) = some tl
⊢ WellFormed le 0 tl

tactic: exact hwf.deleteMin eq₂
state_before: α : Type u_1
s : Heap α
le : α → α → Bool
n : Nat
tl✝ : Heap α
hwf : WellFormed le n s
eq : Option.map (fun x => x.snd) (Heap.deleteMin le s) = some tl✝
a : α
tl : Heap α
eq₂ : Heap.deleteMin le s = some (a, tl)
⊢ WellFormed le 0 ((fun x => x.snd) (a, tl))
Theorem: ConvexOn.secant_mono_aux3
File: Mathlib/Analysis/Convex/Slope.lean

tactic: have hyz' : 0 < z - y := by linarith
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : ConvexOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
⊢ (f z - f x) / (z - x) ≤ (f z - f y) / (z - y)

tactic: have hxz' : 0 < z - x := by linarith
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : ConvexOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
hyz' : 0 < z - y
⊢ (f z - f x) / (z - x) ≤ (f z - f y) / (z - y)

tactic: rw [div_le_div_iff hxz' hyz']
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : ConvexOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
hyz' : 0 < z - y
hxz' : 0 < z - x
⊢ (f z - f x) / (z - x) ≤ (f z - f y) / (z - y)

tactic: linarith only [hf.secant_mono_aux1 hx hz hxy hyz]
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : ConvexOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
hyz' : 0 < z - y
hxz' : 0 < z - x
⊢ (f z - f x) * (z - y) ≤ (f z - f y) * (z - x)

tactic: linarith
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : ConvexOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
⊢ 0 < z - y

tactic: linarith
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : ConvexOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
hyz' : 0 < z - y
⊢ 0 < z - x
Theorem: Fin.Iio_last_eq_map
File: Mathlib/Data/Fintype/Fin.lean

tactic: apply Finset.map_injective Fin.valEmbedding
state_before: α : Type ?u.6717
β : Type ?u.6720
n : ℕ
⊢ Iio (last n) = map castSucc.toEmbedding univ

tactic: rw [Finset.map_map, Fin.map_valEmbedding_Iio, Fin.val_last]
state_before: case a
α : Type ?u.6717
β : Type ?u.6720
n : ℕ
⊢ map valEmbedding (Iio (last n)) = map valEmbedding (map castSucc.toEmbedding univ)

tactic: exact map_valEmbedding_univ.symm
state_before: case a
α : Type ?u.6717
β : Type ?u.6720
n : ℕ
⊢ Iio n = map (Function.Embedding.trans castSucc.toEmbedding valEmbedding) univ
Theorem: Ordinal.CNF_lt_snd
File: Mathlib/SetTheory/Ordinal/CantorNormalForm.lean

tactic: refine' CNFRec b (by simp) (fun o ho IH ↦ _) o
state_before: b o : Ordinal
x : Ordinal × Ordinal
⊢ x ∈ CNF b o → 0 < x.snd

tactic: rw [CNF_ne_zero ho]
state_before: b o✝ : Ordinal
x : Ordinal × Ordinal
o : Ordinal
ho : o ≠ 0
IH : x ∈ CNF b (o % b ^ log b o) → 0 < x.snd
⊢ x ∈ CNF b o → 0 < x.snd

tactic: rintro (h | ⟨_, h⟩)
state_before: b o✝ : Ordinal
x : Ordinal × Ordinal
o : Ordinal
ho : o ≠ 0
IH : x ∈ CNF b (o % b ^ log b o) → 0 < x.snd
⊢ x ∈ (log b o, o / b ^ log b o) :: CNF b (o % b ^ log b o) → 0 < x.snd

tactic: simp
state_before: b o : Ordinal
x : Ordinal × Ordinal
⊢ x ∈ CNF b 0 → 0 < x.snd

tactic: exact div_opow_log_pos b ho
state_before: case head
b o✝ o : Ordinal
ho : o ≠ 0
IH : (log b o, o / b ^ log b o) ∈ CNF b (o % b ^ log b o) → 0 < (log b o, o / b ^ log b o).snd
⊢ 0 < (log b o, o / b ^ log b o).snd

tactic: exact IH h
state_before: case tail
b o✝ : Ordinal
x : Ordinal × Ordinal
o : Ordinal
ho : o ≠ 0
IH : x ∈ CNF b (o % b ^ log b o) → 0 < x.snd
h : Mem x (CNF b (o % b ^ log b o))
⊢ 0 < x.snd
Theorem: Finset.diag_insert
File: Mathlib/Data/Finset/Prod.lean

tactic: rw [insert_eq, insert_eq, diag_union, diag_singleton]
state_before: α : Type u_1
β : Type ?u.128864
γ : Type ?u.128867
inst✝ : DecidableEq α
s t : Finset α
x : α × α
a : α
⊢ diag (insert a s) = insert (a, a) (diag s)
Theorem: CategoryTheory.isCodetector_def
File: Mathlib/CategoryTheory/Generator.lean

tactic: obtain rfl := Set.mem_singleton_iff.1 hH
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
G : C
hG : IsCodetector G
X Y : C
f : X ⟶ Y
hf : ∀ (h : X ⟶ G), ∃! h', f ≫ h' = h
H : C
hH : H ∈ {G}
h : X ⟶ H
⊢ ∃! h', f ≫ h' = h

tactic: exact hf h
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
X Y : C
f : X ⟶ Y
H : C
h : X ⟶ H
hG : IsCodetector H
hf : ∀ (h : X ⟶ H), ∃! h', f ≫ h' = h
hH : H ∈ {H}
⊢ ∃! h', f ≫ h' = h
Theorem: MeasureTheory.OuterMeasure.le_sum_caratheodory
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: simp [fun i => MeasurableSpace.measurableSet_iInf.1 h i t, ENNReal.tsum_add]
state_before: α : Type u_2
ι : Type u_1
m : ι → OuterMeasure α
s : Set α
h : MeasurableSet s
t : Set α
⊢ ↑(sum m) t = ↑(sum m) (t ∩ s) + ↑(sum m) (t \ s)
Theorem: infEdist_inv
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

tactic: rw [← infEdist_inv_inv, inv_inv]
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s✝ t : Set E
x✝ y x : E
s : Set E
⊢ infEdist x⁻¹ s = infEdist x s⁻¹
Theorem: MeasureTheory.MeasurePreserving.restrict_preimage
File: Mathlib/Dynamics/Ergodic/MeasurePreserving.lean

tactic: rw [← hf.map_eq, restrict_map hf.measurable hs]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.52351
δ : Type ?u.52354
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
μa : Measure α
μb : Measure β
μc : Measure γ
μd : Measure δ
f : α → β
hf : MeasurePreserving f
s : Set β
hs : MeasurableSet s
⊢ map f (restrict μa (f ⁻¹' s)) = restrict μb s
Theorem: LatticeOrderedCommGroup.abs_abs_div_abs_le
File: Mathlib/Algebra/Order/LatticeGroup.lean

tactic: rw [abs_eq_sup_inv, sup_le_iff]
state_before: α : Type u
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
⊢ abs (abs a / abs b) ≤ abs (a / b)

tactic: constructor
state_before: α : Type u
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
⊢ abs a / abs b ≤ abs (a / b) ∧ (abs a / abs b)⁻¹ ≤ abs (a / b)

tactic: apply div_le_iff_le_mul.2
state_before: case left
α : Type u
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
⊢ abs a / abs b ≤ abs (a / b)

tactic: convert mabs_mul_le (a / b) b
state_before: case left
α : Type u
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
⊢ abs a ≤ abs (a / b) * abs b

tactic: rw [div_mul_cancel']
state_before: case h.e'_3.h.e'_3
α : Type u
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
⊢ a = a / b * b

tactic: rw [div_eq_mul_inv, mul_inv_rev, inv_inv, mul_inv_le_iff_le_mul, abs_inv_comm]
state_before: case right
α : Type u
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
⊢ (abs a / abs b)⁻¹ ≤ abs (a / b)

tactic: convert mabs_mul_le (b / a) a
state_before: case right
α : Type u
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
⊢ abs b ≤ abs (b / a) * abs a

tactic: rw [div_mul_cancel']
state_before: case h.e'_3.h.e'_3
α : Type u
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
⊢ b = b / a * a
Theorem: Turing.Tape.move_right_nth
File: Mathlib/Computability/TuringMachine.lean

tactic: conv => rhs; rw [← T.move_right_left]
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
T : Tape Γ
i : ℤ
⊢ nth (move Dir.right T) i = nth T (i + 1)

tactic: rw [Tape.move_left_nth, add_sub_cancel]
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
T : Tape Γ
i : ℤ
⊢ nth (move Dir.right T) i = nth (move Dir.left (move Dir.right T)) (i + 1)
Theorem: Stream'.mem_cons_of_mem
File: Mathlib/Data/Stream/Init.lean

tactic: rw [nth_succ, tail_cons, h]
state_before: α : Type u
β : Type v
δ : Type w
a : α
s : Stream' α
b : α
x✝ : a ∈ s
n : ℕ
h : (fun b => a = b) (nth s n)
⊢ (fun b => a = b) (nth (b :: s) (succ n))
Theorem: add_tsub_add_eq_tsub_right
File: Mathlib/Algebra/Order/Sub/Defs.lean

tactic: refine' add_tsub_add_le_tsub_right.antisymm (tsub_le_iff_right.2 <| le_of_add_le_add_right _)
state_before: α : Type u_1
β : Type ?u.53321
inst✝⁵ : PartialOrder α
inst✝⁴ : AddCommSemigroup α
inst✝³ : Sub α
inst✝² : OrderedSub α
a✝ b✝ c✝ d : α
inst✝¹ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝ : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a c b : α
⊢ a + c - (b + c) = a - b

tactic: exact c
state_before: case refine'_1
α : Type u_1
β : Type ?u.53321
inst✝⁵ : PartialOrder α
inst✝⁴ : AddCommSemigroup α
inst✝³ : Sub α
inst✝² : OrderedSub α
a✝ b✝ c✝ d : α
inst✝¹ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝ : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a c b : α
⊢ α

case refine'_2
α : Type u_1
β : Type ?u.53321
inst✝⁵ : PartialOrder α
inst✝⁴ : AddCommSemigroup α
inst✝³ : Sub α
inst✝² : OrderedSub α
a✝ b✝ c✝ d : α
inst✝¹ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝ : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a c b : α
⊢ a + ?refine'_1 ≤ a + c - (b + c) + b + ?refine'_1

tactic: rw [add_assoc]
state_before: case refine'_2
α : Type u_1
β : Type ?u.53321
inst✝⁵ : PartialOrder α
inst✝⁴ : AddCommSemigroup α
inst✝³ : Sub α
inst✝² : OrderedSub α
a✝ b✝ c✝ d : α
inst✝¹ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝ : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a c b : α
⊢ a + c ≤ a + c - (b + c) + b + c

tactic: exact le_tsub_add
state_before: case refine'_2
α : Type u_1
β : Type ?u.53321
inst✝⁵ : PartialOrder α
inst✝⁴ : AddCommSemigroup α
inst✝³ : Sub α
inst✝² : OrderedSub α
a✝ b✝ c✝ d : α
inst✝¹ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝ : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a c b : α
⊢ a + c ≤ a + c - (b + c) + (b + c)
Theorem: Mathlib.Tactic.Ring.smul_eq_cast
File: Mathlib/Tactic/Ring/Basic.lean

tactic: subst_vars
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a : ℕ
a' b c : R
x✝¹ : ↑a = a'
x✝ : a' * b = c
⊢ a • b = c

tactic: simp
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a : ℕ
b : R
⊢ a • b = ↑a * b
Theorem: Cardinal.mk_list_eq_sum_pow
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: simp
state_before: α✝ β α : Type u
⊢ (#(n : ℕ) × Vector α n) = sum fun n => (#α) ^ n
Theorem: posTangentConeAt_mono
File: Mathlib/Analysis/Calculus/LocalExtr.lean

tactic: rintro s t hst y ⟨c, d, hd, hc, hcd⟩
state_before: E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : E → ℝ
a : E
f' : E →L[ℝ] ℝ
⊢ Monotone fun s => posTangentConeAt s a

tactic: exact ⟨c, d, mem_of_superset hd fun h hn => hst hn, hc, hcd⟩
state_before: case intro.intro.intro.intro
E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : E → ℝ
a : E
f' : E →L[ℝ] ℝ
s t : Set E
hst : s ≤ t
y : E
c : ℕ → ℝ
d : ℕ → E
hd : ∀ᶠ (n : ℕ) in atTop, a + d n ∈ s
hc : Tendsto c atTop atTop
hcd : Tendsto (fun n => c n • d n) atTop (𝓝 y)
⊢ y ∈ (fun s => posTangentConeAt s a) t
Theorem: Real.rpow_le_one_iff_of_pos
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rw [rpow_def_of_pos hx, exp_le_one_iff, mul_nonpos_iff, log_nonneg_iff hx, log_nonpos_iff hx]
state_before: x y z : ℝ
hx : 0 < x
⊢ x ^ y ≤ 1 ↔ 1 ≤ x ∧ y ≤ 0 ∨ x ≤ 1 ∧ 0 ≤ y
Theorem: Asymptotics.superpolynomialDecay_mul_const_iff
File: Mathlib/Analysis/Asymptotics/SuperpolynomialDecay.lean

tactic: simp [mul_assoc, mul_inv_cancel hc0]
state_before: α : Type u_2
β : Type u_1
l : Filter α
k f g g' : α → β
inst✝² : TopologicalSpace β
inst✝¹ : Field β
inst✝ : ContinuousMul β
c : β
hc0 : c ≠ 0
h : SuperpolynomialDecay l k fun n => f n * c
x : α
⊢ f x * c * c⁻¹ = f x
Theorem: let_eq
File: Mathlib/Init/Logic.lean

tactic: simp [h₁, h₂]
state_before: a b c d : Prop
p : ?m.30637
α : Sort v
β : Sort u
a₁ a₂ : α
b₁ b₂ : α → β
h₁ : a₁ = a₂
h₂ : ∀ (x : α), b₁ x = b₂ x
⊢ (let x := a₁;
    b₁ x) =
    let x := a₂;
    b₂ x
Theorem: TypeVec.append1_drop_last
File: Mathlib/Data/TypeVec.lean

tactic: cases i <;> rfl
state_before: n : ℕ
α : TypeVec (n + 1)
i : Fin2 (n + 1)
⊢ (drop α ::: last α) i = α i
Theorem: MeasureTheory.integrable_comp_div_left
File: Mathlib/MeasureTheory/Group/Integration.lean

tactic: refine' ⟨fun h => _, fun h => h.comp_div_left g⟩
state_before: 𝕜 : Type ?u.68496
M : Type ?u.68499
α : Type ?u.68502
G : Type u_1
E : Type ?u.68508
F : Type u_2
inst✝⁹ : MeasurableSpace G
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
inst✝⁵ : NormedAddCommGroup F
μ : Measure G
f✝ : G → E
g✝ : G
inst✝⁴ : Group G
inst✝³ : MeasurableMul G
inst✝² : MeasurableInv G
f : G → F
inst✝¹ : IsInvInvariant μ
inst✝ : IsMulLeftInvariant μ
g : G
⊢ (Integrable fun t => f (g / t)) ↔ Integrable f

tactic: convert h.comp_inv.comp_mul_left g⁻¹
state_before: 𝕜 : Type ?u.68496
M : Type ?u.68499
α : Type ?u.68502
G : Type u_1
E : Type ?u.68508
F : Type u_2
inst✝⁹ : MeasurableSpace G
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
inst✝⁵ : NormedAddCommGroup F
μ : Measure G
f✝ : G → E
g✝ : G
inst✝⁴ : Group G
inst✝³ : MeasurableMul G
inst✝² : MeasurableInv G
f : G → F
inst✝¹ : IsInvInvariant μ
inst✝ : IsMulLeftInvariant μ
g : G
h : Integrable fun t => f (g / t)
⊢ Integrable f

tactic: simp_rw [div_inv_eq_mul, mul_inv_cancel_left]
state_before: case h.e'_5.h.h.e'_1
𝕜 : Type ?u.68496
M : Type ?u.68499
α : Type ?u.68502
G : Type u_1
E : Type ?u.68508
F : Type u_2
inst✝⁹ : MeasurableSpace G
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
inst✝⁵ : NormedAddCommGroup F
μ : Measure G
f✝ : G → E
g✝ : G
inst✝⁴ : Group G
inst✝³ : MeasurableMul G
inst✝² : MeasurableInv G
f : G → F
inst✝¹ : IsInvInvariant μ
inst✝ : IsMulLeftInvariant μ
g : G
h : Integrable fun t => f (g / t)
x✝ : G
⊢ x✝ = g / (g⁻¹ * x✝)⁻¹
Theorem: LocalEquiv.trans_symm_eq_symm_trans_symm
File: Mathlib/Logic/Equiv/LocalEquiv.lean

tactic: cases e
state_before: α : Type u_1
β : Type u_3
γ : Type u_2
δ : Type ?u.44356
e : LocalEquiv α β
e' : LocalEquiv β γ
⊢ LocalEquiv.symm (LocalEquiv.trans e e') = LocalEquiv.trans (LocalEquiv.symm e') (LocalEquiv.symm e)

tactic: cases e'
state_before: case mk
α : Type u_1
β : Type u_3
γ : Type u_2
δ : Type ?u.44356
e' : LocalEquiv β γ
toFun✝ : α → β
invFun✝ : β → α
source✝ : Set α
target✝ : Set β
map_source'✝ : ∀ ⦃x : α⦄, x ∈ source✝ → toFun✝ x ∈ target✝
map_target'✝ : ∀ ⦃x : β⦄, x ∈ target✝ → invFun✝ x ∈ source✝
left_inv'✝ : ∀ ⦃x : α⦄, x ∈ source✝ → invFun✝ (toFun✝ x) = x
right_inv'✝ : ∀ ⦃x : β⦄, x ∈ target✝ → toFun✝ (invFun✝ x) = x
⊢ LocalEquiv.symm
      (LocalEquiv.trans
        { toFun := toFun✝, invFun := invFun✝, source := source✝, target := target✝, map_source' := map_source'✝,
          map_target' := map_target'✝, left_inv' := left_inv'✝, right_inv' := right_inv'✝ }
        e') =
    LocalEquiv.trans (LocalEquiv.symm e')
      (LocalEquiv.symm
        { toFun := toFun✝, invFun := invFun✝, source := source✝, target := target✝, map_source' := map_source'✝,
          map_target' := map_target'✝, left_inv' := left_inv'✝, right_inv' := right_inv'✝ })

tactic: rfl
state_before: case mk.mk
α : Type u_1
β : Type u_3
γ : Type u_2
δ : Type ?u.44356
toFun✝¹ : α → β
invFun✝¹ : β → α
source✝¹ : Set α
target✝¹ : Set β
map_source'✝¹ : ∀ ⦃x : α⦄, x ∈ source✝¹ → toFun✝¹ x ∈ target✝¹
map_target'✝¹ : ∀ ⦃x : β⦄, x ∈ target✝¹ → invFun✝¹ x ∈ source✝¹
left_inv'✝¹ : ∀ ⦃x : α⦄, x ∈ source✝¹ → invFun✝¹ (toFun✝¹ x) = x
right_inv'✝¹ : ∀ ⦃x : β⦄, x ∈ target✝¹ → toFun✝¹ (invFun✝¹ x) = x
toFun✝ : β → γ
invFun✝ : γ → β
source✝ : Set β
target✝ : Set γ
map_source'✝ : ∀ ⦃x : β⦄, x ∈ source✝ → toFun✝ x ∈ target✝
map_target'✝ : ∀ ⦃x : γ⦄, x ∈ target✝ → invFun✝ x ∈ source✝
left_inv'✝ : ∀ ⦃x : β⦄, x ∈ source✝ → invFun✝ (toFun✝ x) = x
right_inv'✝ : ∀ ⦃x : γ⦄, x ∈ target✝ → toFun✝ (invFun✝ x) = x
⊢ LocalEquiv.symm
      (LocalEquiv.trans
        { toFun := toFun✝¹, invFun := invFun✝¹, source := source✝¹, target := target✝¹, map_source' := map_source'✝¹,
          map_target' := map_target'✝¹, left_inv' := left_inv'✝¹, right_inv' := right_inv'✝¹ }
        { toFun := toFun✝, invFun := invFun✝, source := source✝, target := target✝, map_source' := map_source'✝,
          map_target' := map_target'✝, left_inv' := left_inv'✝, right_inv' := right_inv'✝ }) =
    LocalEquiv.trans
      (LocalEquiv.symm
        { toFun := toFun✝, invFun := invFun✝, source := source✝, target := target✝, map_source' := map_source'✝,
          map_target' := map_target'✝, left_inv' := left_inv'✝, right_inv' := right_inv'✝ })
      (LocalEquiv.symm
        { toFun := toFun✝¹, invFun := invFun✝¹, source := source✝¹, target := target✝¹, map_source' := map_source'✝¹,
          map_target' := map_target'✝¹, left_inv' := left_inv'✝¹, right_inv' := right_inv'✝¹ })
Theorem: ZNum.of_nat_cast
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [← Int.cast_ofNat, of_int_cast, Int.cast_ofNat]
state_before: α : Type u_1
inst✝ : AddGroupWithOne α
n : ℕ
⊢ ↑↑n = ↑n
Theorem: CharTwo.add_mul_self
File: Mathlib/Algebra/CharP/Two.lean

tactic: rw [← pow_two, ← pow_two, ← pow_two, add_sq]
state_before: R : Type u_1
ι : Type ?u.10261
inst✝¹ : CommSemiring R
inst✝ : CharP R 2
x y : R
⊢ (x + y) * (x + y) = x * x + y * y
Theorem: integral_one_div
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

tactic: simp only [one_div, integral_inv h]
state_before: a b : ℝ
n : ℕ
h : ¬0 ∈ [[a, b]]
⊢ (∫ (x : ℝ) in a..b, 1 / x) = Real.log (b / a)
Theorem: PadicInt.toZMod_spec
File: Mathlib/NumberTheory/Padics/RingHoms.lean

tactic: convert sub_zmodRepr_mem x using 2
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x : ℤ_[p]
⊢ x - ↑(↑toZMod x) ∈ maximalIdeal ℤ_[p]

tactic: dsimp [toZMod, toZModHom]
state_before: case h.e'_4.h.e'_6
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x : ℤ_[p]
⊢ ↑(↑toZMod x) = ↑(zmodRepr x)

tactic: rcases exists_eq_add_of_lt hp_prime.1.pos with ⟨p', rfl⟩
state_before: case h.e'_4.h.e'_6
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x : ℤ_[p]
⊢ ↑↑(zmodRepr x) = ↑(zmodRepr x)

tactic: change ↑((_ : ZMod (0 + p' + 1)).val) = (_ : ℤ_[0 + p' + 1])
state_before: case h.e'_4.h.e'_6.intro
r : ℚ
p' : ℕ
hp_prime : Fact (Nat.Prime (0 + p' + 1))
x : ℤ_[0 + p' + 1]
⊢ ↑↑(zmodRepr x) = ↑(zmodRepr x)

tactic: simp only [ZMod.val_nat_cast, add_zero, add_def, Nat.cast_inj, zero_add]
state_before: case h.e'_4.h.e'_6.intro
r : ℚ
p' : ℕ
hp_prime : Fact (Nat.Prime (0 + p' + 1))
x : ℤ_[0 + p' + 1]
⊢ ↑(ZMod.val ↑(zmodRepr x)) = ↑(zmodRepr x)

tactic: apply mod_eq_of_lt
state_before: case h.e'_4.h.e'_6.intro
r : ℚ
p' : ℕ
hp_prime : Fact (Nat.Prime (0 + p' + 1))
x : ℤ_[0 + p' + 1]
⊢ zmodRepr x % (p' + 1) = zmodRepr x

tactic: simpa only [zero_add] using zmodRepr_lt_p x
state_before: case h.e'_4.h.e'_6.intro.h
r : ℚ
p' : ℕ
hp_prime : Fact (Nat.Prime (0 + p' + 1))
x : ℤ_[0 + p' + 1]
⊢ zmodRepr x < p' + 1