1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: List.prod_mul_prod_eq_prod_zipWith_mul_prod_drop
File: Mathlib/Algebra/BigOperators/Group/List.lean

tactic: simp [Nat.zero_le]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : CommMonoid M
a : M
l l₁ l₂ ys : List M
⊢ [].prod * ys.prod = (zipWith (fun x x_1 => x * x_1) [] ys).prod * (drop ys.length []).prod * (drop [].length ys).prod
state_after: no goals

tactic: simp [Nat.zero_le]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : CommMonoid M
a : M
l l₁ l₂ xs : List M
⊢ xs.prod * [].prod = (zipWith (fun x x_1 => x * x_1) xs []).prod * (drop [].length xs).prod * (drop xs.length []).prod
state_after: no goals

tactic: simp only [drop, length, zipWith_cons_cons, prod_cons]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : CommMonoid M
a : M
l l₁ l₂ : List M
x : M
xs : List M
y : M
ys : List M
⊢ (x :: xs).prod * (y :: ys).prod =
    (zipWith (fun x x_1 => x * x_1) (x :: xs) (y :: ys)).prod * (drop (y :: ys).length (x :: xs)).prod *
      (drop (x :: xs).length (y :: ys)).prod
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : CommMonoid M
a : M
l l₁ l₂ : List M
x : M
xs : List M
y : M
ys : List M
⊢ x * xs.prod * (y * ys.prod) =
    x * y * (zipWith (fun x x_1 => x * x_1) xs ys).prod * (drop ys.length xs).prod * (drop xs.length ys).prod

tactic: conv =>
  lhs; rw [mul_assoc]; right; rw [mul_comm, mul_assoc]; right
  rw [mul_comm, prod_mul_prod_eq_prod_zipWith_mul_prod_drop xs ys]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : CommMonoid M
a : M
l l₁ l₂ : List M
x : M
xs : List M
y : M
ys : List M
⊢ x * xs.prod * (y * ys.prod) =
    x * y * (zipWith (fun x x_1 => x * x_1) xs ys).prod * (drop ys.length xs).prod * (drop xs.length ys).prod
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : CommMonoid M
a : M
l l₁ l₂ : List M
x : M
xs : List M
y : M
ys : List M
⊢ x * (y * ((zipWith (fun x x_1 => x * x_1) xs ys).prod * (drop ys.length xs).prod * (drop xs.length ys).prod)) =
    x * y * (zipWith (fun x x_1 => x * x_1) xs ys).prod * (drop ys.length xs).prod * (drop xs.length ys).prod

tactic: simp [mul_assoc]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : CommMonoid M
a : M
l l₁ l₂ : List M
x : M
xs : List M
y : M
ys : List M
⊢ x * (y * ((zipWith (fun x x_1 => x * x_1) xs ys).prod * (drop ys.length xs).prod * (drop xs.length ys).prod)) =
    x * y * (zipWith (fun x x_1 => x * x_1) xs ys).prod * (drop ys.length xs).prod * (drop xs.length ys).prod
state_after: no goals
Theorem: Multiset.sup_add
File: Mathlib/Data/Multiset/Lattice.lean

tactic: simp [sup]
state_before: α : Type u_1
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s₁ s₂ : Multiset α
⊢ (s₁ + s₂).sup = fold (fun x x_1 => x ⊔ x_1) (⊥ ⊔ ⊥) (s₁ + s₂)
state_after: no goals
Theorem: MeasureTheory.pdf.integral_mul_eq_integral
File: Mathlib/Probability/Density.lean

tactic: congr with x
state_before: Ω : Type u_1
E : Type u_2
inst✝² : MeasurableSpace E
m : MeasurableSpace Ω
ℙ : Measure Ω
μ : Measure E
inst✝¹ : IsFiniteMeasure ℙ
X : Ω → ℝ
inst✝ : HasPDF X ℙ volume
⊢ ∫ (x : ℝ), x * (pdf X ℙ volume x).toReal = ∫ (x : ℝ), (pdf X ℙ volume x).toReal * x
state_after: case e_f.h
Ω : Type u_1
E : Type u_2
inst✝² : MeasurableSpace E
m : MeasurableSpace Ω
ℙ : Measure Ω
μ : Measure E
inst✝¹ : IsFiniteMeasure ℙ
X : Ω → ℝ
inst✝ : HasPDF X ℙ volume
x : ℝ
⊢ x * (pdf X ℙ volume x).toReal = (pdf X ℙ volume x).toReal * x

tactic: exact mul_comm _ _
state_before: case e_f.h
Ω : Type u_1
E : Type u_2
inst✝² : MeasurableSpace E
m : MeasurableSpace Ω
ℙ : Measure Ω
μ : Measure E
inst✝¹ : IsFiniteMeasure ℙ
X : Ω → ℝ
inst✝ : HasPDF X ℙ volume
x : ℝ
⊢ x * (pdf X ℙ volume x).toReal = (pdf X ℙ volume x).toReal * x
state_after: no goals
Theorem: Polynomial.coeff_C_mul_X
File: Mathlib/Algebra/Polynomial/Coeff.lean

tactic: rw [← pow_one X, coeff_C_mul_X_pow]
state_before: R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
x : R
n : ℕ
⊢ (C x * X).coeff n = if n = 1 then x else 0
state_after: no goals
Theorem: Odd.pow_nonpos_iff
File: Mathlib/Algebra/Order/Ring/Basic.lean

tactic: rw [le_iff_lt_or_eq, le_iff_lt_or_eq, hn.pow_neg_iff, pow_eq_zero_iff]
state_before: α : Type u_1
M : Type u_2
R : Type u_3
inst✝¹ : LinearOrderedSemiring R
a b : R
m n : ℕ
inst✝ : ExistsAddOfLE R
hn : Odd n
⊢ a ^ n ≤ 0 ↔ a ≤ 0
state_after: α : Type u_1
M : Type u_2
R : Type u_3
inst✝¹ : LinearOrderedSemiring R
a b : R
m n : ℕ
inst✝ : ExistsAddOfLE R
hn : Odd n
⊢ n ≠ 0

tactic: rintro rfl
state_before: α : Type u_1
M : Type u_2
R : Type u_3
inst✝¹ : LinearOrderedSemiring R
a b : R
m n : ℕ
inst✝ : ExistsAddOfLE R
hn : Odd n
⊢ n ≠ 0
state_after: α : Type u_1
M : Type u_2
R : Type u_3
inst✝¹ : LinearOrderedSemiring R
a b : R
m : ℕ
inst✝ : ExistsAddOfLE R
hn : Odd 0
⊢ False

tactic: simp [Odd, eq_comm (a := 0)] at hn
state_before: α : Type u_1
M : Type u_2
R : Type u_3
inst✝¹ : LinearOrderedSemiring R
a b : R
m : ℕ
inst✝ : ExistsAddOfLE R
hn : Odd 0
⊢ False
state_after: no goals
Theorem: CochainComplex.HomComplex.Cocycle.cochain_ofHom_homOf_eq_coe
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean

tactic: simpa only [ext_iff] using ofHom_homOf_eq_self z
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
z : Cocycle F G 0
⊢ Cochain.ofHom z.homOf = ↑z
state_after: no goals
Theorem: Basis.toMatrix_map
File: Mathlib/LinearAlgebra/Matrix/Basis.lean

tactic: ext
state_before: ι : Type u_1
ι' : Type u_2
κ : Type u_3
κ' : Type u_4
R : Type u_5
M : Type u_6
inst✝⁷ : CommSemiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
R₂ : Type u_7
M₂ : Type u_8
inst✝⁴ : CommRing R₂
inst✝³ : AddCommGroup M₂
inst✝² : Module R₂ M₂
e : Basis ι R M
v✝ : ι' → M
i : ι
j : ι'
N : Type u_9
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
b✝ : Basis ι R M
b' : Basis ι' R M
c : Basis κ R N
c' : Basis κ' R N
f✝ : M →ₗ[R] N
b : Basis ι R M
f : M ≃ₗ[R] N
v : ι → N
⊢ (b.map f).toMatrix v = b.toMatrix (⇑f.symm ∘ v)
state_after: case a
ι : Type u_1
ι' : Type u_2
κ : Type u_3
κ' : Type u_4
R : Type u_5
M : Type u_6
inst✝⁷ : CommSemiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
R₂ : Type u_7
M₂ : Type u_8
inst✝⁴ : CommRing R₂
inst✝³ : AddCommGroup M₂
inst✝² : Module R₂ M₂
e : Basis ι R M
v✝ : ι' → M
i : ι
j : ι'
N : Type u_9
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
b✝ : Basis ι R M
b' : Basis ι' R M
c : Basis κ R N
c' : Basis κ' R N
f✝ : M →ₗ[R] N
b : Basis ι R M
f : M ≃ₗ[R] N
v : ι → N
i✝ j✝ : ι
⊢ (b.map f).toMatrix v i✝ j✝ = b.toMatrix (⇑f.symm ∘ v) i✝ j✝
Theorem: Finmap.lookup_insert
File: Mathlib/Data/Finmap.lean

tactic: simp only [insert_toFinmap, lookup_toFinmap, AList.lookup_insert]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b : β a
s✝ : Finmap β
s : AList β
⊢ lookup a (insert a b ⟦s⟧) = some b
state_after: no goals
Theorem: CategoryTheory.eq_whisker'
File: Mathlib/Tactic/CategoryTheory/Reassoc.lean

tactic: rw [w]
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : C
f g : X ⟶ Y
w : f = g
Z : C
h : Y ⟶ Z
⊢ f ≫ h = g ≫ h
state_after: no goals
Theorem: List.periodic_prod
File: Mathlib/Algebra/Periodic.lean

tactic: induction' l with g l ih hl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : Add α
inst✝ : Monoid β
l : List (α → β)
hl : ∀ f ∈ l, Periodic f c
⊢ Periodic l.prod c
state_after: case nil
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : Add α
inst✝ : Monoid β
hl : ∀ f ∈ [], Periodic f c
⊢ Periodic [].prod c

case cons
α : Type u_1
β : Type u_2
γ : Type u_3
f g✝ : α → β
c c₁ c₂ x : α
inst✝¹ : Add α
inst✝ : Monoid β
g : α → β
l : List (α → β)
ih : (∀ f ∈ l, Periodic f c) → Periodic l.prod c
hl : ∀ f ∈ g :: l, Periodic f c
⊢ Periodic (g :: l).prod c

tactic: simp
state_before: case nil
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : Add α
inst✝ : Monoid β
hl : ∀ f ∈ [], Periodic f c
⊢ Periodic [].prod c
state_after: no goals

tactic: rw [List.forall_mem_cons] at hl
state_before: case cons
α : Type u_1
β : Type u_2
γ : Type u_3
f g✝ : α → β
c c₁ c₂ x : α
inst✝¹ : Add α
inst✝ : Monoid β
g : α → β
l : List (α → β)
ih : (∀ f ∈ l, Periodic f c) → Periodic l.prod c
hl : ∀ f ∈ g :: l, Periodic f c
⊢ Periodic (g :: l).prod c
state_after: case cons
α : Type u_1
β : Type u_2
γ : Type u_3
f g✝ : α → β
c c₁ c₂ x : α
inst✝¹ : Add α
inst✝ : Monoid β
g : α → β
l : List (α → β)
ih : (∀ f ∈ l, Periodic f c) → Periodic l.prod c
hl : Periodic g c ∧ ∀ x ∈ l, Periodic x c
⊢ Periodic (g :: l).prod c

tactic: simpa only [List.prod_cons] using hl.1.mul (ih hl.2)
state_before: case cons
α : Type u_1
β : Type u_2
γ : Type u_3
f g✝ : α → β
c c₁ c₂ x : α
inst✝¹ : Add α
inst✝ : Monoid β
g : α → β
l : List (α → β)
ih : (∀ f ∈ l, Periodic f c) → Periodic l.prod c
hl : Periodic g c ∧ ∀ x ∈ l, Periodic x c
⊢ Periodic (g :: l).prod c
state_after: no goals
Theorem: HomologicalComplex.exactAt_iff
File: Mathlib/Algebra/Homology/ShortComplex/HomologicalComplex.lean

tactic: rfl
state_before: C : Type u_1
inst✝¹ : Category.{u_3, u_1} C
inst✝ : HasZeroMorphisms C
ι : Type u_2
c : ComplexShape ι
K L : HomologicalComplex C c
i j k : ι
⊢ K.ExactAt i ↔ (K.sc i).Exact
state_after: no goals
Theorem: CharP.char_ne_one
File: Mathlib/Algebra/CharP/Defs.lean

tactic: simpa using (cast_eq_zero_iff R p 1).mpr (hp ▸ dvd_refl p)
state_before: R : Type u_1
inst✝¹ : NonAssocSemiring R
inst✝ : Nontrivial R
p : ℕ
hc : CharP R p
hp : p = 1
⊢ 1 = 0
state_after: no goals
Theorem: FirstOrder.Language.Theory.isSatisfiable_directed_union_iff
File: Mathlib/ModelTheory/Satisfiability.lean

tactic: refine ⟨fun h' i => h'.mono (Set.subset_iUnion _ _), fun h' => ?_⟩
state_before: L : Language
T✝ : L.Theory
α : Type w
n : ℕ
T' : L.Theory
ι : Type u_1
inst✝ : Nonempty ι
T : ι → L.Theory
h : Directed (fun x x_1 => x ⊆ x_1) T
⊢ IsSatisfiable (⋃ i, T i) ↔ ∀ (i : ι), (T i).IsSatisfiable
state_after: L : Language
T✝ : L.Theory
α : Type w
n : ℕ
T' : L.Theory
ι : Type u_1
inst✝ : Nonempty ι
T : ι → L.Theory
h : Directed (fun x x_1 => x ⊆ x_1) T
h' : ∀ (i : ι), (T i).IsSatisfiable
⊢ IsSatisfiable (⋃ i, T i)

tactic: rw [isSatisfiable_iff_isFinitelySatisfiable, IsFinitelySatisfiable]
state_before: L : Language
T✝ : L.Theory
α : Type w
n : ℕ
T' : L.Theory
ι : Type u_1
inst✝ : Nonempty ι
T : ι → L.Theory
h : Directed (fun x x_1 => x ⊆ x_1) T
h' : ∀ (i : ι), (T i).IsSatisfiable
⊢ IsSatisfiable (⋃ i, T i)
state_after: L : Language
T✝ : L.Theory
α : Type w
n : ℕ
T' : L.Theory
ι : Type u_1
inst✝ : Nonempty ι
T : ι → L.Theory
h : Directed (fun x x_1 => x ⊆ x_1) T
h' : ∀ (i : ι), (T i).IsSatisfiable
⊢ ∀ (T0 : Finset L.Sentence), ↑T0 ⊆ ⋃ i, T i → IsSatisfiable ↑T0

tactic: intro T0 hT0
state_before: L : Language
T✝ : L.Theory
α : Type w
n : ℕ
T' : L.Theory
ι : Type u_1
inst✝ : Nonempty ι
T : ι → L.Theory
h : Directed (fun x x_1 => x ⊆ x_1) T
h' : ∀ (i : ι), (T i).IsSatisfiable
⊢ ∀ (T0 : Finset L.Sentence), ↑T0 ⊆ ⋃ i, T i → IsSatisfiable ↑T0
state_after: L : Language
T✝ : L.Theory
α : Type w
n : ℕ
T' : L.Theory
ι : Type u_1
inst✝ : Nonempty ι
T : ι → L.Theory
h : Directed (fun x x_1 => x ⊆ x_1) T
h' : ∀ (i : ι), (T i).IsSatisfiable
T0 : Finset L.Sentence
hT0 : ↑T0 ⊆ ⋃ i, T i
⊢ IsSatisfiable ↑T0

tactic: obtain ⟨i, hi⟩ := h.exists_mem_subset_of_finset_subset_biUnion hT0
state_before: L : Language
T✝ : L.Theory
α : Type w
n : ℕ
T' : L.Theory
ι : Type u_1
inst✝ : Nonempty ι
T : ι → L.Theory
h : Directed (fun x x_1 => x ⊆ x_1) T
h' : ∀ (i : ι), (T i).IsSatisfiable
T0 : Finset L.Sentence
hT0 : ↑T0 ⊆ ⋃ i, T i
⊢ IsSatisfiable ↑T0
state_after: case intro
L : Language
T✝ : L.Theory
α : Type w
n : ℕ
T' : L.Theory
ι : Type u_1
inst✝ : Nonempty ι
T : ι → L.Theory
h : Directed (fun x x_1 => x ⊆ x_1) T
h' : ∀ (i : ι), (T i).IsSatisfiable
T0 : Finset L.Sentence
hT0 : ↑T0 ⊆ ⋃ i, T i
i : ι
hi : ↑T0 ⊆ T i
⊢ IsSatisfiable ↑T0

tactic: exact (h' i).mono hi
state_before: case intro
L : Language
T✝ : L.Theory
α : Type w
n : ℕ
T' : L.Theory
ι : Type u_1
inst✝ : Nonempty ι
T : ι → L.Theory
h : Directed (fun x x_1 => x ⊆ x_1) T
h' : ∀ (i : ι), (T i).IsSatisfiable
T0 : Finset L.Sentence
hT0 : ↑T0 ⊆ ⋃ i, T i
i : ι
hi : ↑T0 ⊆ T i
⊢ IsSatisfiable ↑T0
state_after: no goals
Theorem: CategoryTheory.Limits.inr_coprodZeroIso_hom
File: Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean

tactic: dsimp [coprodZeroIso, binaryCofanZeroRight]
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
⊢ coprod.inl ≫ (coprodZeroIso X).hom = 𝟙 X
state_after: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
⊢ coprod.inl ≫
      (colimit.isoColimitCocone
          { cocone := BinaryCofan.mk (𝟙 X) 0, isColimit := binaryCofanZeroRightIsColimit X }).hom =
    𝟙 X

tactic: simp
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
⊢ coprod.inl ≫
      (colimit.isoColimitCocone
          { cocone := BinaryCofan.mk (𝟙 X) 0, isColimit := binaryCofanZeroRightIsColimit X }).hom =
    𝟙 X
state_after: no goals
Theorem: Orientation.areaForm_to_volumeForm
File: Mathlib/Analysis/InnerProductSpace/TwoDim.lean

tactic: simp [areaForm]
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x y : E
⊢ (o.areaForm x) y = o.volumeForm ![x, y]
state_after: no goals
Theorem: Filter.mem_coclosedCompact
File: Mathlib/Topology/Compactness/Compact.lean

tactic: simp only [hasBasis_coclosedCompact.mem_iff, and_assoc]
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
⊢ s ∈ coclosedCompact X ↔ ∃ t, IsClosed t ∧ IsCompact t ∧ tᶜ ⊆ s
state_after: no goals
Theorem: harmonic_not_int
File: Mathlib/NumberTheory/Harmonic/Int.lean

tactic: apply padicNorm.not_int_of_not_padic_int 2
state_before: n : ℕ
h : 2 ≤ n
⊢ ¬(harmonic n).isInt = true
state_after: n : ℕ
h : 2 ≤ n
⊢ 1 < padicNorm 2 (harmonic n)

tactic: rw [padicNorm.eq_zpow_of_nonzero (harmonic_pos (ne_zero_of_lt h)).ne',
    padicValRat_two_harmonic, neg_neg, zpow_natCast]
state_before: n : ℕ
h : 2 ≤ n
⊢ 1 < padicNorm 2 (harmonic n)
state_after: n : ℕ
h : 2 ≤ n
⊢ 1 < ↑2 ^ Nat.log 2 n

tactic: exact one_lt_pow one_lt_two (Nat.log_pos one_lt_two h).ne'
state_before: n : ℕ
h : 2 ≤ n
⊢ 1 < ↑2 ^ Nat.log 2 n
state_after: no goals
Theorem: Complex.tendsto_self_mul_Gamma_nhds_zero
File: Mathlib/Analysis/SpecialFunctions/Gamma/Basic.lean

tactic: rw [show 𝓝 (1 : ℂ) = 𝓝 (Gamma (0 + 1)) by simp only [zero_add, Complex.Gamma_one]]
state_before: ⊢ Tendsto (fun z => z * Gamma z) (𝓝[≠] 0) (𝓝 1)
state_after: ⊢ Tendsto (fun z => z * Gamma z) (𝓝[≠] 0) (𝓝 (Gamma (0 + 1)))

tactic: convert (Tendsto.mono_left _ nhdsWithin_le_nhds).congr'
  (eventuallyEq_of_mem self_mem_nhdsWithin Complex.Gamma_add_one)
state_before: ⊢ Tendsto (fun z => z * Gamma z) (𝓝[≠] 0) (𝓝 (Gamma (0 + 1)))
state_after: case convert_1

⊢ Tendsto (fun x => Gamma (x + 1)) (𝓝 0) (𝓝 (Gamma (0 + 1)))

tactic: refine ContinuousAt.comp (g := Gamma) ?_ (continuous_id.add continuous_const).continuousAt
state_before: case convert_1

⊢ Tendsto (fun x => Gamma (x + 1)) (𝓝 0) (𝓝 (Gamma (0 + 1)))
state_after: case convert_1

⊢ ContinuousAt Gamma (0 + 1)

tactic: refine (Complex.differentiableAt_Gamma _ fun m => ?_).continuousAt
state_before: case convert_1

⊢ ContinuousAt Gamma (0 + 1)
state_after: case convert_1
m : ℕ
⊢ 0 + 1 ≠ -↑m

tactic: rw [zero_add, ← ofReal_natCast, ← ofReal_neg, ← ofReal_one, Ne, ofReal_inj]
state_before: case convert_1
m : ℕ
⊢ 0 + 1 ≠ -↑m
state_after: case convert_1
m : ℕ
⊢ ¬1 = -↑m

tactic: refine (lt_of_le_of_lt ?_ zero_lt_one).ne'
state_before: case convert_1
m : ℕ
⊢ ¬1 = -↑m
state_after: case convert_1
m : ℕ
⊢ -↑m ≤ 0

tactic: exact neg_nonpos.mpr (Nat.cast_nonneg _)
state_before: case convert_1
m : ℕ
⊢ -↑m ≤ 0
state_after: no goals

tactic: simp only [zero_add, Complex.Gamma_one]
state_before: ⊢ 𝓝 1 = 𝓝 (Gamma (0 + 1))
state_after: no goals
Theorem: mabs_mul_le
File: Mathlib/Algebra/Order/Group/Abs.lean

tactic: apply sup_le
state_before: α : Type u_1
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b✝ a b : α
⊢ mabs (a * b) ≤ mabs a * mabs b
state_after: case a
α : Type u_1
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b✝ a b : α
⊢ a * b ≤ mabs a * mabs b

case a
α : Type u_1
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b✝ a b : α
⊢ (a * b)⁻¹ ≤ mabs a * mabs b

tactic: exact mul_le_mul' (le_mabs_self a) (le_mabs_self b)
state_before: case a
α : Type u_1
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b✝ a b : α
⊢ a * b ≤ mabs a * mabs b
state_after: no goals

tactic: rw [mul_inv]
state_before: case a
α : Type u_1
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b✝ a b : α
⊢ (a * b)⁻¹ ≤ mabs a * mabs b
state_after: case a
α : Type u_1
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b✝ a b : α
⊢ a⁻¹ * b⁻¹ ≤ mabs a * mabs b

tactic: exact mul_le_mul' (inv_le_mabs _) (inv_le_mabs _)
state_before: case a
α : Type u_1
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b✝ a b : α
⊢ a⁻¹ * b⁻¹ ≤ mabs a * mabs b
state_after: no goals
Theorem: SimpleGraph.Path.mk'_mem_edges_singleton
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: simp [singleton]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
h : G.Adj u v
⊢ s(u, v) ∈ (↑(singleton h)).edges
state_after: no goals
Theorem: List.range_map_iterate
File: Mathlib/Data/List/Iterate.lean

tactic: apply List.ext_get <;> simp
state_before: α : Type u_1
n : ℕ
f : α → α
a : α
⊢ map (fun x => f^[x] a) (range n) = iterate f a n
state_after: no goals
Theorem: pNilradical_eq_nilradical
File: Mathlib/FieldTheory/IsPerfectClosure.lean

tactic: rw [pNilradical, if_pos hp]
state_before: R : Type u_1
inst✝ : CommSemiring R
p : ℕ
hp : 1 < p
⊢ pNilradical R p = nilradical R
state_after: no goals
Theorem: MeasureTheory.measurePreserving_sumPiEquivProdPi_symm
File: Mathlib/MeasureTheory/Constructions/Pi.lean

tactic: refine (pi_eq fun s _ => ?_).symm
state_before: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
inst✝³ : Fintype ι
m✝¹ : (i : ι) → OuterMeasure (α i)
m✝ : (i : ι) → MeasurableSpace (α i)
μ✝ : (i : ι) → Measure (α i)
inst✝² : ∀ (i : ι), SigmaFinite (μ✝ i)
inst✝¹ : Fintype ι'
π : ι ⊕ ι' → Type u_4
m : (i : ι ⊕ ι') → MeasurableSpace (π i)
μ : (i : ι ⊕ ι') → Measure (π i)
inst✝ : ∀ (i : ι ⊕ ι'), SigmaFinite (μ i)
⊢ Measure.map (⇑(MeasurableEquiv.sumPiEquivProdPi π).symm)
      ((Measure.pi fun i => μ (Sum.inl i)).prod (Measure.pi fun i => μ (Sum.inr i))) =
    Measure.pi μ
state_after: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
inst✝³ : Fintype ι
m✝¹ : (i : ι) → OuterMeasure (α i)
m✝ : (i : ι) → MeasurableSpace (α i)
μ✝ : (i : ι) → Measure (α i)
inst✝² : ∀ (i : ι), SigmaFinite (μ✝ i)
inst✝¹ : Fintype ι'
π : ι ⊕ ι' → Type u_4
m : (i : ι ⊕ ι') → MeasurableSpace (π i)
μ : (i : ι ⊕ ι') → Measure (π i)
inst✝ : ∀ (i : ι ⊕ ι'), SigmaFinite (μ i)
s : (i : ι ⊕ ι') → Set (π i)
x✝ : ∀ (i : ι ⊕ ι'), MeasurableSet (s i)
⊢ (Measure.map (⇑(MeasurableEquiv.sumPiEquivProdPi π).symm)
        ((Measure.pi fun i => μ (Sum.inl i)).prod (Measure.pi fun i => μ (Sum.inr i))))
      (univ.pi s) =
    ∏ i : ι ⊕ ι', (μ i) (s i)

tactic: simp_rw [MeasurableEquiv.map_apply, MeasurableEquiv.coe_sumPiEquivProdPi_symm,
  Equiv.sumPiEquivProdPi_symm_preimage_univ_pi, Measure.prod_prod, Measure.pi_pi,
  Fintype.prod_sum_type]
state_before: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
inst✝³ : Fintype ι
m✝¹ : (i : ι) → OuterMeasure (α i)
m✝ : (i : ι) → MeasurableSpace (α i)
μ✝ : (i : ι) → Measure (α i)
inst✝² : ∀ (i : ι), SigmaFinite (μ✝ i)
inst✝¹ : Fintype ι'
π : ι ⊕ ι' → Type u_4
m : (i : ι ⊕ ι') → MeasurableSpace (π i)
μ : (i : ι ⊕ ι') → Measure (π i)
inst✝ : ∀ (i : ι ⊕ ι'), SigmaFinite (μ i)
s : (i : ι ⊕ ι') → Set (π i)
x✝ : ∀ (i : ι ⊕ ι'), MeasurableSet (s i)
⊢ (Measure.map (⇑(MeasurableEquiv.sumPiEquivProdPi π).symm)
        ((Measure.pi fun i => μ (Sum.inl i)).prod (Measure.pi fun i => μ (Sum.inr i))))
      (univ.pi s) =
    ∏ i : ι ⊕ ι', (μ i) (s i)
state_after: no goals
Theorem: SetTheory.PGame.nim_one_moveLeft
File: Mathlib/SetTheory/Game/Nim.lean

tactic: simp
state_before: x : (nim 1).LeftMoves
⊢ (nim 1).moveLeft x = nim 0
state_after: no goals
Theorem: Int.lcm_dvd
File: Mathlib/Data/Int/GCD.lean

tactic: rw [Int.lcm]
state_before: i j k : ℤ
⊢ i ∣ k → j ∣ k → ↑(i.lcm j) ∣ k
state_after: i j k : ℤ
⊢ i ∣ k → j ∣ k → ↑(i.natAbs.lcm j.natAbs) ∣ k

tactic: intro hi hj
state_before: i j k : ℤ
⊢ i ∣ k → j ∣ k → ↑(i.natAbs.lcm j.natAbs) ∣ k
state_after: i j k : ℤ
hi : i ∣ k
hj : j ∣ k
⊢ ↑(i.natAbs.lcm j.natAbs) ∣ k

tactic: exact natCast_dvd.mpr (Nat.lcm_dvd (natAbs_dvd_natAbs.mpr hi) (natAbs_dvd_natAbs.mpr hj))
state_before: i j k : ℤ
hi : i ∣ k
hj : j ∣ k
⊢ ↑(i.natAbs.lcm j.natAbs) ∣ k
state_after: no goals
Theorem: Filter.map_iInf_eq
File: Mathlib/Order/Filter/Basic.lean

tactic: simpa only [le_principal_iff, mem_map]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l : Filter α
f : ι → Filter α
m : α → β
hf : Directed (fun x x_1 => x ≥ x_1) f
inst✝ : Nonempty ι
s : Set β
hs : m ⁻¹' s ∈ iInf f
i : ι
hi : m ⁻¹' s ∈ f i
⊢ map m (f i) ≤ 𝓟 s
state_after: no goals
Theorem: Traversable.traverse_eq_map_id'
File: Mathlib/Control/Traversable/Lemmas.lean

tactic: ext
state_before: t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g : α → F β
h : β → G γ
f✝ : β → γ
x : t β
f : β → γ
⊢ traverse (pure ∘ f) = pure ∘ map f
state_after: case h
t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g : α → F β
h : β → G γ
f✝ : β → γ
x : t β
f : β → γ
x✝ : t β
⊢ traverse (pure ∘ f) x✝ = (pure ∘ map f) x✝

tactic: exact traverse_eq_map_id _ _
state_before: case h
t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g : α → F β
h : β → G γ
f✝ : β → γ
x : t β
f : β → γ
x✝ : t β
⊢ traverse (pure ∘ f) x✝ = (pure ∘ map f) x✝
state_after: no goals