1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: HolorIndex.take_take
File: Mathlib/Data/Holor.lean

tactic: simp [assocRight, take, cast_type, List.take_take, Nat.le_add_right, min_eq_left]
state_before: ds₁ ds₂ ds₃ is : List ℕ
h : Forall₂ (fun x x_1 => x < x_1) is (ds₁ ++ ds₂ ++ ds₃)
⊢ ↑(assocRight ⟨is, h⟩).take = ↑(take ⟨is, h⟩).take
state_after: no goals
Theorem: WithZeroTopology.hasBasis_nhds_of_ne_zero
File: Mathlib/Topology/Algebra/WithZeroTopology.lean

tactic: rw [nhds_of_ne_zero h]
state_before: α : Type u_1
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
γ γ₁ γ₂ : Γ₀
l : Filter α
f : α → Γ₀
x : Γ₀
h : x ≠ 0
⊢ (𝓝 x).HasBasis (fun x => True) fun x_1 => {x}
state_after: α : Type u_1
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
γ γ₁ γ₂ : Γ₀
l : Filter α
f : α → Γ₀
x : Γ₀
h : x ≠ 0
⊢ (pure x).HasBasis (fun x => True) fun x_1 => {x}

tactic: exact hasBasis_pure _
state_before: α : Type u_1
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
γ γ₁ γ₂ : Γ₀
l : Filter α
f : α → Γ₀
x : Γ₀
h : x ≠ 0
⊢ (pure x).HasBasis (fun x => True) fun x_1 => {x}
state_after: no goals
Theorem: SetTheory.PGame.neg_equiv_neg_iff
File: Mathlib/SetTheory/Game/PGame.lean

tactic: show Equiv (-x) (-y) ↔ Equiv x y
state_before: xl xr : Type u
x y : PGame
⊢ -x ≈ -y ↔ x ≈ y
state_after: xl xr : Type u
x y : PGame
⊢ (-x).Equiv (-y) ↔ x.Equiv y

tactic: rw [Equiv, Equiv, neg_le_neg_iff, neg_le_neg_iff, and_comm]
state_before: xl xr : Type u
x y : PGame
⊢ (-x).Equiv (-y) ↔ x.Equiv y
state_after: no goals
Theorem: Cardinal.toNat_apply_of_aleph0_le
File: Mathlib/SetTheory/Cardinal/ToNat.lean

tactic: simp [h]
state_before: α : Type u
c✝ d : Cardinal.{u}
c : Cardinal.{u_1}
h : ℵ₀ ≤ c
⊢ toNat c = 0
state_after: no goals
Theorem: QuaternionAlgebra.rank_eq_four
File: Mathlib/Algebra/Quaternion.lean

tactic: rw [rank_eq_card_basis (basisOneIJK c₁ c₂), Fintype.card_fin]
state_before: S : Type u_1
T : Type u_2
R : Type u_3
inst✝¹ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
inst✝ : StrongRankCondition R
⊢ Module.rank R ℍ[R,c₁,c₂] = 4
state_after: S : Type u_1
T : Type u_2
R : Type u_3
inst✝¹ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
inst✝ : StrongRankCondition R
⊢ ↑4 = 4

tactic: norm_num
state_before: S : Type u_1
T : Type u_2
R : Type u_3
inst✝¹ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
inst✝ : StrongRankCondition R
⊢ ↑4 = 4
state_after: no goals
Theorem: Polynomial.map_eq_zero
File: Mathlib/Algebra/Polynomial/FieldDivision.lean

tactic: simp only [Polynomial.ext_iff]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝² : DivisionRing R
p q : R[X]
inst✝¹ : Semiring S
inst✝ : Nontrivial S
f : R →+* S
⊢ map f p = 0 ↔ p = 0
state_after: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝² : DivisionRing R
p q : R[X]
inst✝¹ : Semiring S
inst✝ : Nontrivial S
f : R →+* S
⊢ (∀ (n : ℕ), (map f p).coeff n = coeff 0 n) ↔ ∀ (n : ℕ), p.coeff n = coeff 0 n

tactic: congr!
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝² : DivisionRing R
p q : R[X]
inst✝¹ : Semiring S
inst✝ : Nontrivial S
f : R →+* S
⊢ (∀ (n : ℕ), (map f p).coeff n = coeff 0 n) ↔ ∀ (n : ℕ), p.coeff n = coeff 0 n
state_after: case a.h.a
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝² : DivisionRing R
p q : R[X]
inst✝¹ : Semiring S
inst✝ : Nontrivial S
f : R →+* S
a✝ : ℕ
⊢ (map f p).coeff a✝ = coeff 0 a✝ ↔ p.coeff a✝ = coeff 0 a✝

tactic: simp [map_eq_zero, coeff_map, coeff_zero]
state_before: case a.h.a
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝² : DivisionRing R
p q : R[X]
inst✝¹ : Semiring S
inst✝ : Nontrivial S
f : R →+* S
a✝ : ℕ
⊢ (map f p).coeff a✝ = coeff 0 a✝ ↔ p.coeff a✝ = coeff 0 a✝
state_after: no goals
Theorem: Complex.normSq_eq_abs
File: Mathlib/Data/Complex/Abs.lean

tactic: simp [abs, sq, abs_def, Real.mul_self_sqrt (normSq_nonneg _)]
state_before: x : ℂ
⊢ normSq x = abs x ^ 2
state_after: no goals
Theorem: measurableSet_setOf
File: Mathlib/MeasureTheory/MeasurableSpace/Basic.lean

tactic: simpa only [preimage_singleton_true]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
inst✝ : MeasurableSpace α
p q : α → Prop
h : MeasurableSet {a | p a}
⊢ MeasurableSet (p ⁻¹' {True})
state_after: no goals

tactic: simpa using h (measurableSet_singleton True)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
inst✝ : MeasurableSpace α
p q : α → Prop
h : Measurable p
⊢ MeasurableSet {a | p a}
state_after: no goals
Theorem: Set.Finite.toFinset_empty
File: Mathlib/Data/Set/Finite.lean

tactic: simp
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
a : α
hs : s.Finite
ht : t.Finite
h : ∅.Finite
⊢ h.toFinset = ∅
state_after: no goals
Theorem: Ideal.IsRadical.inf
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: rw [IsRadical, radical_inf]
state_before: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I J K L : Ideal R
hI : I.IsRadical
hJ : J.IsRadical
⊢ (I ⊓ J).IsRadical
state_after: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I J K L : Ideal R
hI : I.IsRadical
hJ : J.IsRadical
⊢ I.radical ⊓ J.radical ≤ I ⊓ J

tactic: exact inf_le_inf hI hJ
state_before: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I J K L : Ideal R
hI : I.IsRadical
hJ : J.IsRadical
⊢ I.radical ⊓ J.radical ≤ I ⊓ J
state_after: no goals
Theorem: SetTheory.PGame.quot_right_distrib_sub
File: Mathlib/SetTheory/Game/Basic.lean

tactic: change (⟦(y + -z) * x⟧ : Game) = ⟦y * x⟧ + -⟦z * x⟧
state_before: x y z : PGame
⊢ ⟦(y - z) * x⟧ = ⟦y * x⟧ - ⟦z * x⟧
state_after: x y z : PGame
⊢ ⟦(y + -z) * x⟧ = ⟦y * x⟧ + -⟦z * x⟧

tactic: rw [quot_right_distrib, quot_neg_mul]
state_before: x y z : PGame
⊢ ⟦(y + -z) * x⟧ = ⟦y * x⟧ + -⟦z * x⟧
state_after: no goals
Theorem: Matrix.zpow_bit0
File: Mathlib/LinearAlgebra/Matrix/ZPow.lean

tactic: rcases le_total 0 n with nonneg | nonpos
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
n : ℤ
⊢ A ^ bit0 n = A ^ n * A ^ n
state_after: case inl
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
n : ℤ
nonneg : 0 ≤ n
⊢ A ^ bit0 n = A ^ n * A ^ n

case inr
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
n : ℤ
nonpos : n ≤ 0
⊢ A ^ bit0 n = A ^ n * A ^ n

tactic: exact zpow_add_of_nonneg nonneg nonneg
state_before: case inl
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
n : ℤ
nonneg : 0 ≤ n
⊢ A ^ bit0 n = A ^ n * A ^ n
state_after: no goals

tactic: exact zpow_add_of_nonpos nonpos nonpos
state_before: case inr
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
n : ℤ
nonpos : n ≤ 0
⊢ A ^ bit0 n = A ^ n * A ^ n
state_after: no goals
Theorem: Option.map₂_none_right
File: Mathlib/Data/Option/NAry.lean

tactic: cases a <;> rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
f✝ : α → β → γ
a✝ : Option α
b : Option β
c : Option γ
f : α → β → γ
a : Option α
⊢ map₂ f a none = none
state_after: no goals
Theorem: ppow_mul'
File: Mathlib/Algebra/Group/PNatPowAssoc.lean

tactic: rw [mul_comm]
state_before: M : Type u_1
inst✝² : Mul M
inst✝¹ : Pow M ℕ+
inst✝ : PNatPowAssoc M
x : M
m n : ℕ+
⊢ x ^ (m * n) = (x ^ n) ^ m
state_after: M : Type u_1
inst✝² : Mul M
inst✝¹ : Pow M ℕ+
inst✝ : PNatPowAssoc M
x : M
m n : ℕ+
⊢ x ^ (n * m) = (x ^ n) ^ m

tactic: exact ppow_mul x n m
state_before: M : Type u_1
inst✝² : Mul M
inst✝¹ : Pow M ℕ+
inst✝ : PNatPowAssoc M
x : M
m n : ℕ+
⊢ x ^ (n * m) = (x ^ n) ^ m
state_after: no goals
Theorem: Nat.mem_primesBelow
File: Mathlib/NumberTheory/SmoothNumbers.lean

tactic: simp [primesBelow]
state_before: k n : ℕ
⊢ n ∈ k.primesBelow ↔ n < k ∧ Prime n
state_after: no goals
Theorem: Matrix.circulant_isSymm_iff
File: Mathlib/LinearAlgebra/Matrix/Circulant.lean

tactic: rw [IsSymm, transpose_circulant, circulant_inj, funext_iff]
state_before: α : Type u_1
β : Type u_2
m : Type u_3
n : Type u_4
R : Type u_5
inst✝ : AddGroup n
v : n → α
⊢ (circulant v).IsSymm ↔ ∀ (i : n), v (-i) = v i
state_after: no goals
Theorem: Cardinal.mul_eq_max_of_aleph0_le_right
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: rw [mul_comm, max_comm]
state_before: a b : Cardinal.{u_1}
h' : a ≠ 0
h : ℵ₀ ≤ b
⊢ a * b = max a b
state_after: a b : Cardinal.{u_1}
h' : a ≠ 0
h : ℵ₀ ≤ b
⊢ b * a = max b a

tactic: exact mul_eq_max_of_aleph0_le_left h h'
state_before: a b : Cardinal.{u_1}
h' : a ≠ 0
h : ℵ₀ ≤ b
⊢ b * a = max b a
state_after: no goals
Theorem: List.map_pmap
File: Mathlib/Data/List/Basic.lean

tactic: induction l <;> [rfl; simp only [*, pmap, map]]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Prop
g : β → γ
f : (a : α) → p a → β
l : List α
H : ∀ (a : α), a ∈ l → p a
⊢ map g (pmap f l H) = pmap (fun a h => g (f a h)) l H
state_after: no goals
Theorem: Complex.abs_cpow_le
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: by_cases h : z = 0 → w.re = 0 → w = 0
state_before: z w : ℂ
⊢ abs (z ^ w) ≤ abs z ^ w.re / rexp (z.arg * w.im)
state_after: case pos
z w : ℂ
h : z = 0 → w.re = 0 → w = 0
⊢ abs (z ^ w) ≤ abs z ^ w.re / rexp (z.arg * w.im)

case neg
z w : ℂ
h : ¬(z = 0 → w.re = 0 → w = 0)
⊢ abs (z ^ w) ≤ abs z ^ w.re / rexp (z.arg * w.im)

tactic: exact (abs_cpow_of_imp h).le
state_before: case pos
z w : ℂ
h : z = 0 → w.re = 0 → w = 0
⊢ abs (z ^ w) ≤ abs z ^ w.re / rexp (z.arg * w.im)
state_after: no goals

tactic: push_neg at h
state_before: case neg
z w : ℂ
h : ¬(z = 0 → w.re = 0 → w = 0)
⊢ abs (z ^ w) ≤ abs z ^ w.re / rexp (z.arg * w.im)
state_after: case neg
z w : ℂ
h : z = 0 ∧ w.re = 0 ∧ w ≠ 0
⊢ abs (z ^ w) ≤ abs z ^ w.re / rexp (z.arg * w.im)

tactic: simp [h]
state_before: case neg
z w : ℂ
h : z = 0 ∧ w.re = 0 ∧ w ≠ 0
⊢ abs (z ^ w) ≤ abs z ^ w.re / rexp (z.arg * w.im)
state_after: no goals
Theorem: mul_inv
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionCommMonoid α
a b c d : α
⊢ (a * b)⁻¹ = a⁻¹ * b⁻¹
state_after: no goals
Theorem: IsSelfAdjoint.mul_star_self
File: Mathlib/Algebra/Star/SelfAdjoint.lean

tactic: simpa only [star_star] using star_mul_self (star x)
state_before: R : Type u_1
A : Type u_2
inst✝¹ : Mul R
inst✝ : StarMul R
x : R
⊢ IsSelfAdjoint (x * star x)
state_after: no goals
Theorem: Matrix.updateColumn_conjTranspose
File: Mathlib/Data/Matrix/RowCol.lean

tactic: rw [conjTranspose, conjTranspose, transpose_map, transpose_map, updateColumn_transpose,
  map_updateRow]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
M : Matrix m n α
i : m
j : n
b : n → α
c : m → α
inst✝¹ : DecidableEq m
inst✝ : Star α
⊢ Mᴴ.updateColumn i (star b) = (M.updateRow i b)ᴴ
state_after: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
M : Matrix m n α
i : m
j : n
b : n → α
c : m → α
inst✝¹ : DecidableEq m
inst✝ : Star α
⊢ ((M.map star).updateRow i (star b))ᵀ = ((M.map star).updateRow i (star ∘ b))ᵀ

tactic: rfl
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
M : Matrix m n α
i : m
j : n
b : n → α
c : m → α
inst✝¹ : DecidableEq m
inst✝ : Star α
⊢ ((M.map star).updateRow i (star b))ᵀ = ((M.map star).updateRow i (star ∘ b))ᵀ
state_after: no goals
Theorem: Ordinal.add_le_right_iff_mul_omega_le
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

tactic: rw [← add_eq_right_iff_mul_omega_le]
state_before: a b : Ordinal.{u_1}
⊢ a + b ≤ b ↔ a * ω ≤ b
state_after: a b : Ordinal.{u_1}
⊢ a + b ≤ b ↔ a + b = b

tactic: exact (add_isNormal a).le_iff_eq
state_before: a b : Ordinal.{u_1}
⊢ a + b ≤ b ↔ a + b = b
state_after: no goals
Theorem: Function.Commute.iterate_pos_le_iff_map_le'
File: Mathlib/Order/Iterate.lean

tactic: simpa only [not_lt] using not_congr (h.symm.iterate_pos_lt_iff_map_lt hg hf hn)
state_before: α : Type u_1
inst✝ : LinearOrder α
f g : α → α
h : Commute f g
hf : StrictMono f
hg : Monotone g
x : α
n : ℕ
hn : 0 < n
⊢ f^[n] x ≤ g^[n] x ↔ f x ≤ g x
state_after: no goals
Theorem: SemiconjBy.units_zpow_right
File: Mathlib/Algebra/Group/Semiconj/Units.lean

tactic: simp only [zpow_natCast, Units.val_pow_eq_pow_val, h, pow_right]
state_before: M : Type u_1
G : Type u_2
inst✝ : Monoid M
a : M
x y : Mˣ
h : SemiconjBy a ↑x ↑y
n : ℕ
⊢ SemiconjBy a ↑(x ^ ↑n) ↑(y ^ ↑n)
state_after: no goals

tactic: simp only [zpow_negSucc, Units.val_pow_eq_pow_val, units_inv_right, h, pow_right]
state_before: M : Type u_1
G : Type u_2
inst✝ : Monoid M
a : M
x y : Mˣ
h : SemiconjBy a ↑x ↑y
n : ℕ
⊢ SemiconjBy a ↑(x ^ -[n+1]) ↑(y ^ -[n+1])
state_after: no goals
Theorem: Finmap.keys_union
File: Mathlib/Data/Finmap.lean

tactic: simp [keys]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
s₁✝ s₂✝ : Finmap β
s₁ s₂ : AList β
⊢ ∀ (a : α), a ∈ (⟦s₁⟧ ∪ ⟦s₂⟧).keys ↔ a ∈ ⟦s₁⟧.keys ∪ ⟦s₂⟧.keys
state_after: no goals
Theorem: Set.pairwise_insert
File: Mathlib/Data/Set/Pairwise/Basic.lean

tactic: simp only [insert_eq, pairwise_union, pairwise_singleton, true_and_iff, mem_singleton_iff,
  forall_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
r p q : α → α → Prop
f g : ι → α
s t u : Set α
a b : α
⊢ (insert a s).Pairwise r ↔ s.Pairwise r ∧ ∀ b ∈ s, a ≠ b → r a b ∧ r b a
state_after: no goals
Theorem: inv_mul_lt_of_lt_mul₀
File: Mathlib/Algebra/Order/GroupWithZero/Canonical.lean

tactic: rw [mul_comm] at *
state_before: α : Type u_1
inst✝ : LinearOrderedCommGroupWithZero α
a b c d : α
m n : ℕ
h : a < b * c
⊢ b⁻¹ * a < c
state_after: α : Type u_1
inst✝ : LinearOrderedCommGroupWithZero α
a b c d : α
m n : ℕ
h : a < c * b
⊢ a * b⁻¹ < c

tactic: exact mul_inv_lt_of_lt_mul₀ h
state_before: α : Type u_1
inst✝ : LinearOrderedCommGroupWithZero α
a b c d : α
m n : ℕ
h : a < c * b
⊢ a * b⁻¹ < c
state_after: no goals
Theorem: Complex.arg_I
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: simp [arg, le_refl]
state_before: a x z : ℂ
⊢ I.arg = π / 2
state_after: no goals
Theorem: Complex.hasDerivAt_log_sub_logTaylor
File: Mathlib/Analysis/SpecialFunctions/Complex/LogBounds.lean

tactic: convert ((hasDerivAt_log hz).comp_const_add 1 z).sub (hasDerivAt_logTaylor n z) using 1
state_before: n : ℕ
z : ℂ
hz : 1 + z ∈ slitPlane
⊢ HasDerivAt (fun z => log (1 + z) - logTaylor (n + 1) z) ((-z) ^ n * (1 + z)⁻¹) z
state_after: case h.e'_7
n : ℕ
z : ℂ
hz : 1 + z ∈ slitPlane
⊢ (-z) ^ n * (1 + z)⁻¹ = (1 + z)⁻¹ - ∑ j ∈ Finset.range n, (-1) ^ j * z ^ j

tactic: have hz' : -z ≠ 1 := by
  intro H
  rw [neg_eq_iff_eq_neg] at H
  simp only [H, add_right_neg] at hz
  exact slitPlane_ne_zero hz rfl
state_before: case h.e'_7
n : ℕ
z : ℂ
hz : 1 + z ∈ slitPlane
⊢ (-z) ^ n * (1 + z)⁻¹ = (1 + z)⁻¹ - ∑ j ∈ Finset.range n, (-1) ^ j * z ^ j
state_after: case h.e'_7
n : ℕ
z : ℂ
hz : 1 + z ∈ slitPlane
hz' : -z ≠ 1
⊢ (-z) ^ n * (1 + z)⁻¹ = (1 + z)⁻¹ - ∑ j ∈ Finset.range n, (-1) ^ j * z ^ j

tactic: simp_rw [← mul_pow, neg_one_mul, geom_sum_eq hz', ← neg_add', div_neg, add_comm z]
state_before: case h.e'_7
n : ℕ
z : ℂ
hz : 1 + z ∈ slitPlane
hz' : -z ≠ 1
⊢ (-z) ^ n * (1 + z)⁻¹ = (1 + z)⁻¹ - ∑ j ∈ Finset.range n, (-1) ^ j * z ^ j
state_after: case h.e'_7
n : ℕ
z : ℂ
hz : 1 + z ∈ slitPlane
hz' : -z ≠ 1
⊢ (-z) ^ n * (1 + z)⁻¹ = (1 + z)⁻¹ - -(((-z) ^ n - 1) / (1 + z))

tactic: field_simp [slitPlane_ne_zero hz]
state_before: case h.e'_7
n : ℕ
z : ℂ
hz : 1 + z ∈ slitPlane
hz' : -z ≠ 1
⊢ (-z) ^ n * (1 + z)⁻¹ = (1 + z)⁻¹ - -(((-z) ^ n - 1) / (1 + z))
state_after: no goals

tactic: intro H
state_before: n : ℕ
z : ℂ
hz : 1 + z ∈ slitPlane
⊢ -z ≠ 1
state_after: n : ℕ
z : ℂ
hz : 1 + z ∈ slitPlane
H : -z = 1
⊢ False

tactic: rw [neg_eq_iff_eq_neg] at H
state_before: n : ℕ
z : ℂ
hz : 1 + z ∈ slitPlane
H : -z = 1
⊢ False
state_after: n : ℕ
z : ℂ
hz : 1 + z ∈ slitPlane
H : z = -1
⊢ False

tactic: simp only [H, add_right_neg] at hz
state_before: n : ℕ
z : ℂ
hz : 1 + z ∈ slitPlane
H : z = -1
⊢ False
state_after: n : ℕ
z : ℂ
H : z = -1
hz : 0 ∈ slitPlane
⊢ False

tactic: exact slitPlane_ne_zero hz rfl
state_before: n : ℕ
z : ℂ
H : z = -1
hz : 0 ∈ slitPlane
⊢ False
state_after: no goals
Theorem: LatticeHom.cancel_left
File: Mathlib/Order/Hom/Lattice.lean

tactic: rw [← LatticeHom.comp_apply, h, LatticeHom.comp_apply]
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
inst✝⁴ : FunLike F α β
inst✝³ : Lattice α
inst✝² : Lattice β
inst✝¹ : Lattice γ
inst✝ : Lattice δ
g : LatticeHom β γ
f₁ f₂ : LatticeHom α β
hg : Injective ⇑g
h : g.comp f₁ = g.comp f₂
a : α
⊢ g (f₁ a) = g (f₂ a)
state_after: no goals
Theorem: associated_one_iff_isUnit
File: Mathlib/Algebra/Associated.lean

tactic: simp [h]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : Monoid α
a : α
x✝ : IsUnit a
c : αˣ
h : ↑c = a
⊢ 1 * ↑c = a
state_after: no goals
Theorem: MeasureTheory.IsSetSemiring.disjoint_diffFinset₀
File: Mathlib/MeasureTheory/SetSemiring.lean

tactic: by_contra h
state_before: α : Type u_1
C : Set (Set α)
s t : Set α
I : Finset (Set α)
hC : IsSetSemiring C
hs : s ∈ C
hI : ↑I ⊆ C
⊢ Disjoint I (hC.diffFinset₀ hs hI)
state_after: α : Type u_1
C : Set (Set α)
s t : Set α
I : Finset (Set α)
hC : IsSetSemiring C
hs : s ∈ C
hI : ↑I ⊆ C
h : ¬Disjoint I (hC.diffFinset₀ hs hI)
⊢ False

tactic: rw [Finset.not_disjoint_iff] at h
state_before: α : Type u_1
C : Set (Set α)
s t : Set α
I : Finset (Set α)
hC : IsSetSemiring C
hs : s ∈ C
hI : ↑I ⊆ C
h : ¬Disjoint I (hC.diffFinset₀ hs hI)
⊢ False
state_after: α : Type u_1
C : Set (Set α)
s t : Set α
I : Finset (Set α)
hC : IsSetSemiring C
hs : s ∈ C
hI : ↑I ⊆ C
h : ∃ a ∈ I, a ∈ hC.diffFinset₀ hs hI
⊢ False

tactic: obtain ⟨u, huI, hu_diffFinset₀⟩ := h
state_before: α : Type u_1
C : Set (Set α)
s t : Set α
I : Finset (Set α)
hC : IsSetSemiring C
hs : s ∈ C
hI : ↑I ⊆ C
h : ∃ a ∈ I, a ∈ hC.diffFinset₀ hs hI
⊢ False
state_after: case intro.intro
α : Type u_1
C : Set (Set α)
s t : Set α
I : Finset (Set α)
hC : IsSetSemiring C
hs : s ∈ C
hI : ↑I ⊆ C
u : Set α
huI : u ∈ I
hu_diffFinset₀ : u ∈ hC.diffFinset₀ hs hI
⊢ False

tactic: have h_disj : u ≤ ⊥ := hC.disjoint_sUnion_diffFinset₀ hs hI (subset_sUnion_of_mem huI)
  (subset_sUnion_of_mem hu_diffFinset₀)
state_before: case intro.intro
α : Type u_1
C : Set (Set α)
s t : Set α
I : Finset (Set α)
hC : IsSetSemiring C
hs : s ∈ C
hI : ↑I ⊆ C
u : Set α
huI : u ∈ I
hu_diffFinset₀ : u ∈ hC.diffFinset₀ hs hI
⊢ False
state_after: case intro.intro
α : Type u_1
C : Set (Set α)
s t : Set α
I : Finset (Set α)
hC : IsSetSemiring C
hs : s ∈ C
hI : ↑I ⊆ C
u : Set α
huI : u ∈ I
hu_diffFinset₀ : u ∈ hC.diffFinset₀ hs hI
h_disj : u ≤ ⊥
⊢ False

tactic: simp only [Set.bot_eq_empty, Set.le_eq_subset, subset_empty_iff] at h_disj
state_before: case intro.intro
α : Type u_1
C : Set (Set α)
s t : Set α
I : Finset (Set α)
hC : IsSetSemiring C
hs : s ∈ C
hI : ↑I ⊆ C
u : Set α
huI : u ∈ I
hu_diffFinset₀ : u ∈ hC.diffFinset₀ hs hI
h_disj : u ≤ ⊥
⊢ False
state_after: case intro.intro
α : Type u_1
C : Set (Set α)
s t : Set α
I : Finset (Set α)
hC : IsSetSemiring C
hs : s ∈ C
hI : ↑I ⊆ C
u : Set α
huI : u ∈ I
hu_diffFinset₀ : u ∈ hC.diffFinset₀ hs hI
h_disj : u = ∅
⊢ False

tactic: refine hC.empty_not_mem_diffFinset₀ hs hI ?_
state_before: case intro.intro
α : Type u_1
C : Set (Set α)
s t : Set α
I : Finset (Set α)
hC : IsSetSemiring C
hs : s ∈ C
hI : ↑I ⊆ C
u : Set α
huI : u ∈ I
hu_diffFinset₀ : u ∈ hC.diffFinset₀ hs hI
h_disj : u = ∅
⊢ False
state_after: case intro.intro
α : Type u_1
C : Set (Set α)
s t : Set α
I : Finset (Set α)
hC : IsSetSemiring C
hs : s ∈ C
hI : ↑I ⊆ C
u : Set α
huI : u ∈ I
hu_diffFinset₀ : u ∈ hC.diffFinset₀ hs hI
h_disj : u = ∅
⊢ ∅ ∈ hC.diffFinset₀ hs hI

tactic: rwa [h_disj] at hu_diffFinset₀
state_before: case intro.intro
α : Type u_1
C : Set (Set α)
s t : Set α
I : Finset (Set α)
hC : IsSetSemiring C
hs : s ∈ C
hI : ↑I ⊆ C
u : Set α
huI : u ∈ I
hu_diffFinset₀ : u ∈ hC.diffFinset₀ hs hI
h_disj : u = ∅
⊢ ∅ ∈ hC.diffFinset₀ hs hI
state_after: no goals
Theorem: ArithmeticFunction.coe_zeta_mul_moebius
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: rw [mul_comm, moebius_mul_coe_zeta]
state_before: R : Type u_1
⊢ ↑ζ * μ = 1
state_after: no goals
Theorem: CompHaus.pullback_snd_eq
File: Mathlib/Topology/Category/CompHaus/Limits.lean

tactic: dsimp [pullbackIsoPullback]
state_before: X Y B : CompHaus
f : X ⟶ B
g : Y ⟶ B
⊢ pullback.snd f g = (pullbackIsoPullback f g).hom ≫ Limits.pullback.snd
state_after: X Y B : CompHaus
f : X ⟶ B
g : Y ⟶ B
⊢ pullback.snd f g =
    ((pullback.isLimit f g).conePointUniqueUpToIso (limit.isLimit (cospan f g))).hom ≫ Limits.pullback.snd

tactic: simp only [Limits.limit.conePointUniqueUpToIso_hom_comp, pullback.cone_pt, pullback.cone_π]
state_before: X Y B : CompHaus
f : X ⟶ B
g : Y ⟶ B
⊢ pullback.snd f g =
    ((pullback.isLimit f g).conePointUniqueUpToIso (limit.isLimit (cospan f g))).hom ≫ Limits.pullback.snd
state_after: no goals
Theorem: MvPolynomial.rename_monomial
File: Mathlib/Algebra/MvPolynomial/Rename.lean

tactic: rw [rename, aeval_monomial, monomial_eq (s := Finsupp.mapDomain f d),
  Finsupp.prod_mapDomain_index]
state_before: σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
d : σ →₀ ℕ
r : R
⊢ (rename f) ((monomial d) r) = (monomial (Finsupp.mapDomain f d)) r
state_after: σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
d : σ →₀ ℕ
r : R
⊢ ((algebraMap R (MvPolynomial τ R)) r * d.prod fun i k => (X ∘ f) i ^ k) = C r * d.prod fun a m => X (f a) ^ m

case h_zero
σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
d : σ →₀ ℕ
r : R
⊢ ∀ (b : τ), X b ^ 0 = 1

case h_add
σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
d : σ →₀ ℕ
r : R
⊢ ∀ (b : τ) (m₁ m₂ : ℕ), X b ^ (m₁ + m₂) = X b ^ m₁ * X b ^ m₂

tactic: rfl
state_before: σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
d : σ →₀ ℕ
r : R
⊢ ((algebraMap R (MvPolynomial τ R)) r * d.prod fun i k => (X ∘ f) i ^ k) = C r * d.prod fun a m => X (f a) ^ m
state_after: no goals

tactic: exact fun n => pow_zero _
state_before: case h_zero
σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
d : σ →₀ ℕ
r : R
⊢ ∀ (b : τ), X b ^ 0 = 1
state_after: no goals

tactic: exact fun n i₁ i₂ => pow_add _ _ _
state_before: case h_add
σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
d : σ →₀ ℕ
r : R
⊢ ∀ (b : τ) (m₁ m₂ : ℕ), X b ^ (m₁ + m₂) = X b ^ m₁ * X b ^ m₂
state_after: no goals
Theorem: Filter.not_disjoint_self_iff
File: Mathlib/Order/Filter/Basic.lean

tactic: rw [disjoint_self, neBot_iff]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s t : Set α
⊢ ¬Disjoint f f ↔ f.NeBot
state_after: no goals
Theorem: WeierstrassCurve.Φ_neg
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean

tactic: simp only [Φ, ΨSq_neg, neg_add_eq_sub, ← neg_sub n, preΨ_neg, ← neg_add', preΨ_neg, neg_mul_neg,
  mul_comm <| W.preΨ <| n - 1, even_neg]
state_before: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
n : ℤ
⊢ W.Φ (-n) = W.Φ n
state_after: no goals
Theorem: Set.Ioc_union_Ioc_right
File: Mathlib/Order/Interval/Set/Basic.lean

tactic: rw [Ioc_union_Ioc, min_self] <;> exact (min_le_left _ _).trans (le_max_left _ _)
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
a a₁ a₂ b b₁ b₂ c d : α
⊢ Ioc a b ∪ Ioc a c = Ioc a (max b c)
state_after: no goals