tasksource/leandojo huggingface dataset:
Theorem: Equiv.Perm.IsCycle.eq_on_support_inter_nonempty_congr
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: have hx'' : x ∈ g.support := by rwa [mem_support, ← hx, ← mem_support]
state_before: ι : Type ?u.1125909
α : Type u_1
β : Type ?u.1125915
f g : Perm α
x y : α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hf : IsCycle f
hg : IsCycle g
h : ∀ (x : α), x ∈ support f ∩ support g → ↑f x = ↑g x
hx : ↑f x = ↑g x
hx' : x ∈ support f
⊢ f = g

tactic: have : f.support ⊆ g.support := by
  intro y hy
  obtain ⟨k, rfl⟩ := hf.exists_pow_eq (mem_support.mp hx') (mem_support.mp hy)
  rwa [pow_eq_on_of_mem_support h _ _ (mem_inter_of_mem hx' hx''), pow_apply_mem_support]
state_before: ι : Type ?u.1125909
α : Type u_1
β : Type ?u.1125915
f g : Perm α
x y : α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hf : IsCycle f
hg : IsCycle g
h : ∀ (x : α), x ∈ support f ∩ support g → ↑f x = ↑g x
hx : ↑f x = ↑g x
hx' : x ∈ support f
hx'' : x ∈ support g
⊢ f = g

tactic: rw [(inter_eq_left_iff_subset _ _).mpr this] at h
state_before: ι : Type ?u.1125909
α : Type u_1
β : Type ?u.1125915
f g : Perm α
x y : α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hf : IsCycle f
hg : IsCycle g
h : ∀ (x : α), x ∈ support f ∩ support g → ↑f x = ↑g x
hx : ↑f x = ↑g x
hx' : x ∈ support f
hx'' : x ∈ support g
this : support f ⊆ support g
⊢ f = g

tactic: exact hf.support_congr hg this h
state_before: ι : Type ?u.1125909
α : Type u_1
β : Type ?u.1125915
f g : Perm α
x y : α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hf : IsCycle f
hg : IsCycle g
h : ∀ (x : α), x ∈ support f → ↑f x = ↑g x
hx : ↑f x = ↑g x
hx' : x ∈ support f
hx'' : x ∈ support g
this : support f ⊆ support g
⊢ f = g

tactic: rwa [mem_support, ← hx, ← mem_support]
state_before: ι : Type ?u.1125909
α : Type u_1
β : Type ?u.1125915
f g : Perm α
x y : α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hf : IsCycle f
hg : IsCycle g
h : ∀ (x : α), x ∈ support f ∩ support g → ↑f x = ↑g x
hx : ↑f x = ↑g x
hx' : x ∈ support f
⊢ x ∈ support g

tactic: intro y hy
state_before: ι : Type ?u.1125909
α : Type u_1
β : Type ?u.1125915
f g : Perm α
x y : α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hf : IsCycle f
hg : IsCycle g
h : ∀ (x : α), x ∈ support f ∩ support g → ↑f x = ↑g x
hx : ↑f x = ↑g x
hx' : x ∈ support f
hx'' : x ∈ support g
⊢ support f ⊆ support g

tactic: obtain ⟨k, rfl⟩ := hf.exists_pow_eq (mem_support.mp hx') (mem_support.mp hy)
state_before: ι : Type ?u.1125909
α : Type u_1
β : Type ?u.1125915
f g : Perm α
x y✝ : α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hf : IsCycle f
hg : IsCycle g
h : ∀ (x : α), x ∈ support f ∩ support g → ↑f x = ↑g x
hx : ↑f x = ↑g x
hx' : x ∈ support f
hx'' : x ∈ support g
y : α
hy : y ∈ support f
⊢ y ∈ support g

tactic: rwa [pow_eq_on_of_mem_support h _ _ (mem_inter_of_mem hx' hx''), pow_apply_mem_support]
state_before: case intro
ι : Type ?u.1125909
α : Type u_1
β : Type ?u.1125915
f g : Perm α
x y : α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hf : IsCycle f
hg : IsCycle g
h : ∀ (x : α), x ∈ support f ∩ support g → ↑f x = ↑g x
hx : ↑f x = ↑g x
hx' : x ∈ support f
hx'' : x ∈ support g
k : ℕ
hy : ↑(f ^ k) x ∈ support f
⊢ ↑(f ^ k) x ∈ support g
Theorem: Primrec₂.curry
File: Mathlib/Computability/Primrec.lean

tactic: rw [← uncurry, Function.uncurry_curry]
state_before: α : Type u_1
β : Type u_2
σ : Type u_3
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable σ
f : α × β → σ
⊢ Primrec₂ (Function.curry f) ↔ Primrec f
Theorem: Real.hasStrictDerivAt_log_of_pos
File: Mathlib/Analysis/SpecialFunctions/Log/Deriv.lean

tactic: have : HasStrictDerivAt log (exp <| log x)⁻¹ x :=
  (hasStrictDerivAt_exp <| log x).of_local_left_inverse (continuousAt_log hx.ne')
      (ne_of_gt <| exp_pos _) <|
    Eventually.mono (lt_mem_nhds hx) @exp_log
state_before: x : ℝ
hx : 0 < x
⊢ HasStrictDerivAt log x⁻¹ x

tactic: rwa [exp_log hx] at this
state_before: x : ℝ
hx : 0 < x
this : HasStrictDerivAt log (exp (log x))⁻¹ x
⊢ HasStrictDerivAt log x⁻¹ x
Theorem: Ideal.eq_zero_of_constant_mem_of_maximal
File: Mathlib/RingTheory/Polynomial/Basic.lean

tactic: refine' Classical.by_contradiction fun hx0 => hI.ne_top ((eq_top_iff_one I).2 _)
state_before: R : Type u
S : Type ?u.193946
inst✝ : Ring R
hR : IsField R
I : Ideal R[X]
hI : IsMaximal I
x : R
hx : ↑C x ∈ I
⊢ x = 0

tactic: obtain ⟨y, hy⟩ := hR.mul_inv_cancel hx0
state_before: R : Type u
S : Type ?u.193946
inst✝ : Ring R
hR : IsField R
I : Ideal R[X]
hI : IsMaximal I
x : R
hx : ↑C x ∈ I
hx0 : ¬x = 0
⊢ 1 ∈ I

tactic: convert I.mul_mem_left (C y) hx
state_before: case intro
R : Type u
S : Type ?u.193946
inst✝ : Ring R
hR : IsField R
I : Ideal R[X]
hI : IsMaximal I
x : R
hx : ↑C x ∈ I
hx0 : ¬x = 0
y : R
hy : x * y = 1
⊢ 1 ∈ I

tactic: rw [← C.map_mul, hR.mul_comm y x, hy, RingHom.map_one]
state_before: case h.e'_4
R : Type u
S : Type ?u.193946
inst✝ : Ring R
hR : IsField R
I : Ideal R[X]
hI : IsMaximal I
x : R
hx : ↑C x ∈ I
hx0 : ¬x = 0
y : R
hy : x * y = 1
⊢ 1 = ↑C y * ↑C x
Theorem: AdjoinRoot.smul_of
File: Mathlib/RingTheory/AdjoinRoot.lean

tactic: rw [of, RingHom.comp_apply, RingHom.comp_apply, smul_mk, smul_C]
state_before: R : Type u
S : Type v
K : Type w
inst✝² : CommRing R
f : R[X]
inst✝¹ : DistribSMul S R
inst✝ : IsScalarTower S R R
a : S
x : R
⊢ a • ↑(of f) x = ↑(of f) (a • x)
Theorem: Cardinal.card_ord
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: let ⟨r, _, e⟩ := ord_eq α
state_before: α✝ : Type ?u.224717
β : Type ?u.224720
γ : Type ?u.224723
r : α✝ → α✝ → Prop
s : β → β → Prop
t : γ → γ → Prop
c : Cardinal
α : Type u_1
⊢ card (ord (Quotient.mk isEquivalent α)) = Quotient.mk isEquivalent α

tactic: simp only [mk'_def, e, card_type]
state_before: α✝ : Type ?u.224717
β : Type ?u.224720
γ : Type ?u.224723
r✝ : α✝ → α✝ → Prop
s : β → β → Prop
t : γ → γ → Prop
c : Cardinal
α : Type u_1
r : α → α → Prop
w✝ : IsWellOrder α r
e : ord (#α) = type r
⊢ card (ord (Quotient.mk isEquivalent α)) = Quotient.mk isEquivalent α
Theorem: List.length_insert_of_mem
File: Std/Data/List/Lemmas.lean

tactic: rw [insert_of_mem h]
state_before: α : Type u_1
inst✝ : DecidableEq α
a : α
l : List α
h : a ∈ l
⊢ length (List.insert a l) = length l
Theorem: MeasureTheory.Measure.ext
File: Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean

tactic: rw [← trimmed, OuterMeasure.trim_congr (h _), trimmed]
state_before: α : Type u_1
β : Type ?u.9977
γ : Type ?u.9980
δ : Type ?u.9983
ι : Type ?u.9986
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
h : ∀ (s : Set α), MeasurableSet s → ↑↑μ₁ s = ↑↑μ₂ s
⊢ ↑μ₁ = ↑μ₂
Theorem: NNReal.coe_natAbs
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: simp only [Int.cast_ofNat, NNReal.coe_nat_cast]
state_before: 𝓕 : Type ?u.1112225
𝕜 : Type ?u.1112228
α : Type ?u.1112231
ι : Type ?u.1112234
κ : Type ?u.1112237
E : Type ?u.1112240
F : Type ?u.1112243
G : Type ?u.1112246
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
n : ℤ
⊢ ↑↑(natAbs n) = ↑↑(natAbs n)

tactic: simp only [Int.coe_natAbs, Int.cast_abs]
state_before: 𝓕 : Type ?u.1112225
𝕜 : Type ?u.1112228
α : Type ?u.1112231
ι : Type ?u.1112234
κ : Type ?u.1112237
E : Type ?u.1112240
F : Type ?u.1112243
G : Type ?u.1112246
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
n : ℤ
⊢ ↑↑(natAbs n) = ↑(abs n)
Theorem: map_bind
File: Mathlib/Control/Basic.lean

tactic: rw [← bind_pure_comp, bind_assoc] <;> simp [bind_pure_comp]
state_before: α β γ : Type u
m : Type u → Type v
inst✝¹ : Monad m
inst✝ : LawfulMonad m
x : m α
g : α → m β
f : β → γ
⊢ f <$> (x >>= g) = do
    let a ← x
    f <$> g a
Theorem: Nat.fib_add
File: Mathlib/Data/Nat/Fib.lean

tactic: induction' n with n ih generalizing m
state_before: m n : ℕ
⊢ fib (m + n + 1) = fib m * fib n + fib (m + 1) * fib (n + 1)

tactic: simp
state_before: case zero
m✝ m : ℕ
⊢ fib (m + zero + 1) = fib m * fib zero + fib (m + 1) * fib (zero + 1)

tactic: intros
state_before: case succ
m✝ n : ℕ
ih : ∀ (m : ℕ), fib (m + n + 1) = fib m * fib n + fib (m + 1) * fib (n + 1)
m : ℕ
⊢ fib (m + succ n + 1) = fib m * fib (succ n) + fib (m + 1) * fib (succ n + 1)

tactic: specialize ih (m + 1)
state_before: case succ
m✝ n : ℕ
ih : ∀ (m : ℕ), fib (m + n + 1) = fib m * fib n + fib (m + 1) * fib (n + 1)
m : ℕ
⊢ fib (m + succ n + 1) = fib m * fib (succ n) + fib (m + 1) * fib (succ n + 1)

tactic: rw [add_assoc m 1 n, add_comm 1 n] at ih
state_before: case succ
m✝ n m : ℕ
ih : fib (m + 1 + n + 1) = fib (m + 1) * fib n + fib (m + 1 + 1) * fib (n + 1)
⊢ fib (m + succ n + 1) = fib m * fib (succ n) + fib (m + 1) * fib (succ n + 1)

tactic: simp only [fib_add_two, ih]
state_before: case succ
m✝ n m : ℕ
ih : fib (m + (n + 1) + 1) = fib (m + 1) * fib n + fib (m + 1 + 1) * fib (n + 1)
⊢ fib (m + succ n + 1) = fib m * fib (succ n) + fib (m + 1) * fib (succ n + 1)

tactic: ring
state_before: case succ
m✝ n m : ℕ
ih : fib (m + (n + 1) + 1) = fib (m + 1) * fib n + fib (m + 1 + 1) * fib (n + 1)
⊢ fib (m + 1) * fib n + (fib m + fib (m + 1)) * fib (n + 1) = fib m * fib (succ n) + fib (m + 1) * (fib n + fib (n + 1))
Theorem: HahnSeries.order_C
File: Mathlib/RingTheory/HahnSeries.lean

tactic: by_cases h : r = 0
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonAssocSemiring R
r : R
⊢ order (↑C r) = 0

tactic: rw [h, C_zero, order_zero]
state_before: case pos
Γ : Type u_1
R : Type u_2
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonAssocSemiring R
r : R
h : r = 0
⊢ order (↑C r) = 0

tactic: exact order_single h
state_before: case neg
Γ : Type u_1
R : Type u_2
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonAssocSemiring R
r : R
h : ¬r = 0
⊢ order (↑C r) = 0
Theorem: Set.IsPwo.mul
File: Mathlib/Data/Finset/MulAntidiagonal.lean

tactic: rw [← image_mul_prod]
state_before: α : Type u_1
s t : Set α
inst✝ : OrderedCancelCommMonoid α
hs : IsPwo s
ht : IsPwo t
⊢ IsPwo (s * t)

tactic: exact (hs.prod ht).image_of_monotone (monotone_fst.mul' monotone_snd)
state_before: α : Type u_1
s t : Set α
inst✝ : OrderedCancelCommMonoid α
hs : IsPwo s
ht : IsPwo t
⊢ IsPwo ((fun x => x.fst * x.snd) '' s ×ˢ t)
Theorem: Finset.card_biUnion
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: simp_rw [card_eq_sum_ones]
state_before: ι : Type ?u.860588
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : DecidableEq β
s : Finset α
t : α → Finset β
h : ∀ (x : α), x ∈ s → ∀ (y : α), y ∈ s → x ≠ y → Disjoint (t x) (t y)
⊢ ∑ a in s, ∑ _i in t a, 1 = ∑ u in s, card (t u)
Theorem: RightDerivMeasurableAux.le_of_mem_a
File: Mathlib/Analysis/Calculus/FDerivMeasurable.lean

tactic: rcases hx with ⟨r', r'mem, hr'⟩
state_before: F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K : Set F
r ε : ℝ
L : F
x : ℝ
hx : x ∈ A f L r ε
y z : ℝ
hy : y ∈ Icc x (x + r / 2)
hz : z ∈ Icc x (x + r / 2)
⊢ ‖f z - f y - (z - y) • L‖ ≤ ε * r

tactic: have A : x + r / 2 ≤ x + r' := by linarith [r'mem.1]
state_before: case intro.intro
F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K : Set F
r ε : ℝ
L : F
x y z : ℝ
hy : y ∈ Icc x (x + r / 2)
hz : z ∈ Icc x (x + r / 2)
r' : ℝ
r'mem : r' ∈ Ioc (r / 2) r
hr' : ∀ (y : ℝ), y ∈ Icc x (x + r') → ∀ (z : ℝ), z ∈ Icc x (x + r') → ‖f z - f y - (z - y) • L‖ ≤ ε * r
⊢ ‖f z - f y - (z - y) • L‖ ≤ ε * r

tactic: exact hr' _ ((Icc_subset_Icc le_rfl A) hy) _ ((Icc_subset_Icc le_rfl A) hz)
state_before: case intro.intro
F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K : Set F
r ε : ℝ
L : F
x y z : ℝ
hy : y ∈ Icc x (x + r / 2)
hz : z ∈ Icc x (x + r / 2)
r' : ℝ
r'mem : r' ∈ Ioc (r / 2) r
hr' : ∀ (y : ℝ), y ∈ Icc x (x + r') → ∀ (z : ℝ), z ∈ Icc x (x + r') → ‖f z - f y - (z - y) • L‖ ≤ ε * r
A : x + r / 2 ≤ x + r'
⊢ ‖f z - f y - (z - y) • L‖ ≤ ε * r

tactic: linarith [r'mem.1]
state_before: F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K : Set F
r ε : ℝ
L : F
x y z : ℝ
hy : y ∈ Icc x (x + r / 2)
hz : z ∈ Icc x (x + r / 2)
r' : ℝ
r'mem : r' ∈ Ioc (r / 2) r
hr' : ∀ (y : ℝ), y ∈ Icc x (x + r') → ∀ (z : ℝ), z ∈ Icc x (x + r') → ‖f z - f y - (z - y) • L‖ ≤ ε * r
⊢ x + r / 2 ≤ x + r'
Theorem: Polynomial.X_pow_sub_C_ne_zero
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: rw [sub_eq_add_neg, ← map_neg C a]
state_before: R : Type u
S : Type v
a✝ b c d : R
n✝ m : ℕ
inst✝¹ : Ring R
inst✝ : Nontrivial R
n : ℕ
hn : 0 < n
a : R
⊢ X ^ n - ↑C a ≠ 0

tactic: exact X_pow_add_C_ne_zero hn _
state_before: R : Type u
S : Type v
a✝ b c d : R
n✝ m : ℕ
inst✝¹ : Ring R
inst✝ : Nontrivial R
n : ℕ
hn : 0 < n
a : R
⊢ X ^ n + ↑C (-a) ≠ 0
Theorem: List.map_bind
File: Mathlib/Data/List/Basic.lean

tactic: simp only [cons_bind, map_cons, map_bind _ _ l]
state_before: ι : Type ?u.2509
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
g : β → List γ
f : α → β
a : α
l : List α
⊢ List.bind (map f (a :: l)) g = List.bind (a :: l) fun a => g (f a)
Theorem: List.get_enum
File: Mathlib/Data/List/Basic.lean

tactic: simpa [length_enum] using i.2
state_before: ι : Type ?u.455762
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
i : Fin (length (enum l))
⊢ ↑i < length l

tactic: convert get_enumFrom _ _ i
state_before: ι : Type ?u.455762
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
i : Fin (length (enum l))
hi : optParam (↑i < length l) (_ : ↑i < length l)
⊢ get (enum l) i = (↑i, get l { val := ↑i, isLt := hi })

tactic: exact (zero_add _).symm
state_before: case h.e'_3.h.e'_3
ι : Type ?u.455762
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
i : Fin (length (enum l))
hi : optParam (↑i < length l) (_ : ↑i < length l)
⊢ ↑i = 0 + ↑i
Theorem: LieAlgebra.derivedLength_eq_derivedLengthOfIdeal
File: Mathlib/Algebra/Lie/Solvable.lean

tactic: let s₁ := { k | derivedSeries R I k = ⊥ }
state_before: R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I✝ J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
I : LieIdeal R L
⊢ derivedLength R { x // x ∈ ↑I } = derivedLengthOfIdeal R L I

tactic: let s₂ := { k | derivedSeriesOfIdeal R L k I = ⊥ }
state_before: R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I✝ J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
I : LieIdeal R L
s₁ : Set ℕ := {k | derivedSeries R { x // x ∈ ↑I } k = ⊥}
⊢ derivedLength R { x // x ∈ ↑I } = derivedLengthOfIdeal R L I

tactic: change sInf s₁ = sInf s₂
state_before: R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I✝ J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
I : LieIdeal R L
s₁ : Set ℕ := {k | derivedSeries R { x // x ∈ ↑I } k = ⊥}
s₂ : Set ℕ := {k | derivedSeriesOfIdeal R L k I = ⊥}
⊢ derivedLength R { x // x ∈ ↑I } = derivedLengthOfIdeal R L I

tactic: congr
state_before: R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I✝ J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
I : LieIdeal R L
s₁ : Set ℕ := {k | derivedSeries R { x // x ∈ ↑I } k = ⊥}
s₂ : Set ℕ := {k | derivedSeriesOfIdeal R L k I = ⊥}
⊢ sInf s₁ = sInf s₂

tactic: ext k
state_before: case e_a
R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I✝ J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
I : LieIdeal R L
s₁ : Set ℕ := {k | derivedSeries R { x // x ∈ ↑I } k = ⊥}
s₂ : Set ℕ := {k | derivedSeriesOfIdeal R L k I = ⊥}
⊢ s₁ = s₂

tactic: exact I.derivedSeries_eq_bot_iff k
state_before: case e_a.h
R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I✝ J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
I : LieIdeal R L
s₁ : Set ℕ := {k | derivedSeries R { x // x ∈ ↑I } k = ⊥}
s₂ : Set ℕ := {k | derivedSeriesOfIdeal R L k I = ⊥}
k : ℕ
⊢ k ∈ s₁ ↔ k ∈ s₂
Theorem: MeasureTheory.Measure.add_haar_preimage_smul
File: Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean

tactic: rw [map_add_haar_smul μ hr]
state_before: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : IsAddHaarMeasure μ
F : Type ?u.1915974
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
r : ℝ
hr : r ≠ 0
s : Set E
⊢ ↑↑(map ((fun x x_1 => x • x_1) r) μ) s = ENNReal.ofReal (abs (r ^ finrank ℝ E)⁻¹) * ↑↑μ s

tactic: rfl
state_before: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : IsAddHaarMeasure μ
F : Type ?u.1915974
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
r : ℝ
hr : r ≠ 0
s : Set E
⊢ ↑↑(ENNReal.ofReal (abs (r ^ finrank ℝ E)⁻¹) • μ) s = ENNReal.ofReal (abs (r ^ finrank ℝ E)⁻¹) * ↑↑μ s
Theorem: CauSeq.lt_of_eq_of_lt
File: Mathlib/Data/Real/CauSeq.lean

tactic: have := pos_add_limZero gh (neg_limZero fg)
state_before: α : Type u_1
inst✝ : LinearOrderedField α
f g h : CauSeq α abs
fg : f ≈ g
gh : g < h
⊢ f < h

tactic: rwa [← sub_eq_add_neg, sub_sub_sub_cancel_right] at this
state_before: α : Type u_1
inst✝ : LinearOrderedField α
f g h : CauSeq α abs
fg : f ≈ g
gh : g < h
this : Pos (h - g + -(f - g))
⊢ f < h
Theorem: Nat.findGreatest_mono_right
File: Mathlib/Data/Nat/Order/Basic.lean

tactic: refine monotone_nat_of_le_succ fun n => ?_
state_before: m n k l : ℕ
P✝ Q : ℕ → Prop
inst✝¹ : DecidablePred P✝
P : ℕ → Prop
inst✝ : DecidablePred P
⊢ Monotone (Nat.findGreatest P)

tactic: rw [findGreatest_succ]
state_before: m n✝ k l : ℕ
P✝ Q : ℕ → Prop
inst✝¹ : DecidablePred P✝
P : ℕ → Prop
inst✝ : DecidablePred P
n : ℕ
⊢ Nat.findGreatest P n ≤ Nat.findGreatest P (n + 1)

tactic: split_ifs
state_before: m n✝ k l : ℕ
P✝ Q : ℕ → Prop
inst✝¹ : DecidablePred P✝
P : ℕ → Prop
inst✝ : DecidablePred P
n : ℕ
⊢ Nat.findGreatest P n ≤ if P (n + 1) then n + 1 else Nat.findGreatest P n

tactic: exact (findGreatest_le n).trans (le_succ _)
state_before: case inl
m n✝ k l : ℕ
P✝ Q : ℕ → Prop
inst✝¹ : DecidablePred P✝
P : ℕ → Prop
inst✝ : DecidablePred P
n : ℕ
h✝ : P (n + 1)
⊢ Nat.findGreatest P n ≤ n + 1

tactic: rfl
state_before: case inr
m n✝ k l : ℕ
P✝ Q : ℕ → Prop
inst✝¹ : DecidablePred P✝
P : ℕ → Prop
inst✝ : DecidablePred P
n : ℕ
h✝ : ¬P (n + 1)
⊢ Nat.findGreatest P n ≤ Nat.findGreatest P n
Theorem: not_isMax_iff
File: Mathlib/Order/Max.lean

tactic: simp [lt_iff_le_not_le, IsMax, not_forall, exists_prop]
state_before: α : Type u_1
β : Type ?u.12549
inst✝ : Preorder α
a b : α
⊢ ¬IsMax a ↔ ∃ b, a < b
Theorem: NormedRing.inverse_one_sub
File: Mathlib/Analysis/NormedSpace/Units.lean

tactic: rw [← inverse_unit (Units.oneSub t h), Units.oneSub_val]
state_before: R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
t : R
h : ‖t‖ < 1
⊢ inverse (1 - t) = ↑(Units.oneSub t h)⁻¹
Theorem: Nat.zero_bits
File: Mathlib/Data/Nat/Bits.lean

tactic: simp [Nat.bits]
state_before: n : ℕ
⊢ bits 0 = []
Theorem: Filter.Tendsto.tendstoUniformlyOnFilter_const
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: simpa only [nhds_eq_comap_uniformity, tendsto_comap_iff] using hg.comp (tendsto_fst (g := p'))
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p'✝ : Filter α
g✝ : ι → α
g : ι → β
b : β
hg : Tendsto g p (𝓝 b)
p' : Filter α
⊢ TendstoUniformlyOnFilter (fun n x => g n) (fun x => b) p p'
Theorem: Polynomial.continuous_eval₂
File: Mathlib/Topology/Algebra/Polynomial.lean

tactic: simp only [eval₂_eq_sum, Finsupp.sum]
state_before: R : Type u_2
S : Type u_1
inst✝³ : Semiring R
inst✝² : TopologicalSpace R
inst✝¹ : TopologicalSemiring R
p✝ : R[X]
inst✝ : Semiring S
p : S[X]
f : S →+* R
⊢ Continuous fun x => eval₂ f x p

tactic: exact continuous_finset_sum _ fun c _ => continuous_const.mul (continuous_pow _)
state_before: R : Type u_2
S : Type u_1
inst✝³ : Semiring R
inst✝² : TopologicalSpace R
inst✝¹ : TopologicalSemiring R
p✝ : R[X]
inst✝ : Semiring S
p : S[X]
f : S →+* R
⊢ Continuous fun x => sum p fun e a => ↑f a * x ^ e
Theorem: HomotopyEquiv.toQuasiIso_inv
File: Mathlib/Algebra/Homology/QuasiIso.lean

tactic: symm
state_before: ι : Type u_3
V : Type u
inst✝¹³ : Category V
inst✝¹² : HasZeroMorphisms V
inst✝¹¹ : HasZeroObject V
inst✝¹⁰ : HasEqualizers V
inst✝⁹ : HasImages V
inst✝⁸ : HasImageMaps V
inst✝⁷ : HasCokernels V
c : ComplexShape ι
C✝ D✝ E : HomologicalComplex V c
W : Type u_2
inst✝⁶ : Category W
inst✝⁵ : Preadditive W
inst✝⁴ : HasCokernels W
inst✝³ : HasImages W
inst✝² : HasEqualizers W
inst✝¹ : HasZeroObject W
inst✝ : HasImageMaps W
C D : HomologicalComplex W c
e : HomotopyEquiv C D
i : ι
⊢ (asIso ((homologyFunctor W c i).map e.hom)).inv = (homologyFunctor W c i).map e.inv

tactic: haveI := e.toQuasiIso.1 i
state_before: ι : Type u_3
V : Type u
inst✝¹³ : Category V
inst✝¹² : HasZeroMorphisms V
inst✝¹¹ : HasZeroObject V
inst✝¹⁰ : HasEqualizers V
inst✝⁹ : HasImages V
inst✝⁸ : HasImageMaps V
inst✝⁷ : HasCokernels V
c : ComplexShape ι
C✝ D✝ E : HomologicalComplex V c
W : Type u_2
inst✝⁶ : Category W
inst✝⁵ : Preadditive W
inst✝⁴ : HasCokernels W
inst✝³ : HasImages W
inst✝² : HasEqualizers W
inst✝¹ : HasZeroObject W
inst✝ : HasImageMaps W
C D : HomologicalComplex W c
e : HomotopyEquiv C D
i : ι
⊢ (homologyFunctor W c i).map e.inv = (asIso ((homologyFunctor W c i).map e.hom)).inv

tactic: simp only [← Iso.hom_comp_eq_id, asIso_hom, ← Functor.map_comp, ← (homologyFunctor W c i).map_id,
  homology_map_eq_of_homotopy e.homotopyHomInvId _]
state_before: ι : Type u_3
V : Type u
inst✝¹³ : Category V
inst✝¹² : HasZeroMorphisms V
inst✝¹¹ : HasZeroObject V
inst✝¹⁰ : HasEqualizers V
inst✝⁹ : HasImages V
inst✝⁸ : HasImageMaps V
inst✝⁷ : HasCokernels V
c : ComplexShape ι
C✝ D✝ E : HomologicalComplex V c
W : Type u_2
inst✝⁶ : Category W
inst✝⁵ : Preadditive W
inst✝⁴ : HasCokernels W
inst✝³ : HasImages W
inst✝² : HasEqualizers W
inst✝¹ : HasZeroObject W
inst✝ : HasImageMaps W
C D : HomologicalComplex W c
e : HomotopyEquiv C D
i : ι
this : IsIso ((homologyFunctor W c i).map e.hom)
⊢ (homologyFunctor W c i).map e.inv = (asIso ((homologyFunctor W c i).map e.hom)).inv
Theorem: isConj_iff_eq
File: Mathlib/Algebra/Group/Conj.lean

tactic: rw [SemiconjBy, mul_comm, ← Units.mul_inv_eq_iff_eq_mul, mul_assoc, c.mul_inv, mul_one] at hc
state_before: α✝ : Type u
β : Type v
inst✝² : Monoid α✝
inst✝¹ : Monoid β
α : Type u_1
inst✝ : CommMonoid α
a b : α
x✝ : IsConj a b
c : αˣ
hc : SemiconjBy (↑c) a b
⊢ a = b

tactic: exact hc
state_before: α✝ : Type u
β : Type v
inst✝² : Monoid α✝
inst✝¹ : Monoid β
α : Type u_1
inst✝ : CommMonoid α
a b : α
x✝ : IsConj a b
c : αˣ
hc : a = b
⊢ a = b

tactic: rw [h]
state_before: α✝ : Type u
β : Type v
inst✝² : Monoid α✝
inst✝¹ : Monoid β
α : Type u_1
inst✝ : CommMonoid α
a b : α
h : a = b
⊢ IsConj a b
Theorem: Int.sub_pos_of_lt
File: Std/Data/Int/Lemmas.lean

tactic: have h := Int.add_lt_add_right h (-b)
state_before: a b : Int
h : b < a
⊢ 0 < a - b

tactic: rwa [Int.add_right_neg] at h
state_before: a b : Int
h✝ : b < a
h : b + -b < a + -b
⊢ 0 < a - b
Theorem: Nat.Linear.Poly.denote_toExpr
File: src/lean/Init/Data/Nat/Linear.lean

tactic: match p with
| [] => simp [toExpr, Expr.denote, Poly.denote]
| (k, v) :: p => simp [toExpr, Expr.denote, Poly.denote]
state_before: ctx : Context
p : Poly
⊢ Expr.denote ctx (toExpr p) = denote ctx p

tactic: simp [toExpr, Expr.denote, Poly.denote]
state_before: ctx : Context
p : Poly
⊢ Expr.denote ctx (toExpr []) = denote ctx []

tactic: simp [toExpr, Expr.denote, Poly.denote]
state_before: ctx : Context
p✝ : Poly
k : Nat
v : Var
p : List (Nat × Var)
⊢ Expr.denote ctx (toExpr ((k, v) :: p)) = denote ctx ((k, v) :: p)