1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: matPolyEquiv_symm_apply_coeff
File: Mathlib/RingTheory/PolynomialAlgebra.lean

tactic: have t : p = matPolyEquiv (matPolyEquiv.symm p) := by simp
state_before: R : Type u_1
A : Type u_2
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
p : (Matrix n n R)[X]
i j : n
k : ℕ
⊢ (matPolyEquiv.symm p i j).coeff k = p.coeff k i j
state_after: R : Type u_1
A : Type u_2
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
p : (Matrix n n R)[X]
i j : n
k : ℕ
t : p = matPolyEquiv (matPolyEquiv.symm p)
⊢ (matPolyEquiv.symm p i j).coeff k = p.coeff k i j

tactic: conv_rhs => rw [t]
state_before: R : Type u_1
A : Type u_2
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
p : (Matrix n n R)[X]
i j : n
k : ℕ
t : p = matPolyEquiv (matPolyEquiv.symm p)
⊢ (matPolyEquiv.symm p i j).coeff k = p.coeff k i j
state_after: R : Type u_1
A : Type u_2
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
p : (Matrix n n R)[X]
i j : n
k : ℕ
t : p = matPolyEquiv (matPolyEquiv.symm p)
⊢ (matPolyEquiv.symm p i j).coeff k = (matPolyEquiv (matPolyEquiv.symm p)).coeff k i j

tactic: simp only [matPolyEquiv_coeff_apply]
state_before: R : Type u_1
A : Type u_2
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
p : (Matrix n n R)[X]
i j : n
k : ℕ
t : p = matPolyEquiv (matPolyEquiv.symm p)
⊢ (matPolyEquiv.symm p i j).coeff k = (matPolyEquiv (matPolyEquiv.symm p)).coeff k i j
state_after: no goals

tactic: simp
state_before: R : Type u_1
A : Type u_2
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
p : (Matrix n n R)[X]
i j : n
k : ℕ
⊢ p = matPolyEquiv (matPolyEquiv.symm p)
state_after: no goals
Theorem: MeasureTheory.JordanDecomposition.real_smul_posPart_neg
File: Mathlib/MeasureTheory/Decomposition/Jordan.lean

tactic: rw [real_smul_def, ← smul_negPart, if_neg (not_le.2 hr), neg_posPart]
state_before: α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
j : JordanDecomposition α
r : ℝ
hr : r < 0
⊢ (r • j).posPart = (-r).toNNReal • j.negPart
state_after: no goals
Theorem: Matrix.mem_range_scalar_iff_commute_stdBasisMatrix'
File: Mathlib/Data/Matrix/Basis.lean

tactic: refine ⟨fun ⟨r, hr⟩ i j => hr ▸ Commute.symm ?_,
  fun hM => mem_range_scalar_iff_commute_stdBasisMatrix.mpr <| fun i j _ => hM i j⟩
state_before: l : Type u_1
m : Type u_2
n : Type u_3
R : Type u_4
α : Type u_5
inst✝⁴ : DecidableEq l
inst✝³ : DecidableEq m
inst✝² : DecidableEq n
inst✝¹ : Semiring α
inst✝ : Fintype n
M : Matrix n n α
⊢ M ∈ Set.range ⇑(scalar n) ↔ ∀ (i j : n), Commute (stdBasisMatrix i j 1) M
state_after: l : Type u_1
m : Type u_2
n : Type u_3
R : Type u_4
α : Type u_5
inst✝⁴ : DecidableEq l
inst✝³ : DecidableEq m
inst✝² : DecidableEq n
inst✝¹ : Semiring α
inst✝ : Fintype n
M : Matrix n n α
x✝ : M ∈ Set.range ⇑(scalar n)
i j : n
r : α
hr : (scalar n) r = M
⊢ Commute ((scalar n) r) (stdBasisMatrix i j 1)

tactic: rw [scalar_commute_iff]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
R : Type u_4
α : Type u_5
inst✝⁴ : DecidableEq l
inst✝³ : DecidableEq m
inst✝² : DecidableEq n
inst✝¹ : Semiring α
inst✝ : Fintype n
M : Matrix n n α
x✝ : M ∈ Set.range ⇑(scalar n)
i j : n
r : α
hr : (scalar n) r = M
⊢ Commute ((scalar n) r) (stdBasisMatrix i j 1)
state_after: l : Type u_1
m : Type u_2
n : Type u_3
R : Type u_4
α : Type u_5
inst✝⁴ : DecidableEq l
inst✝³ : DecidableEq m
inst✝² : DecidableEq n
inst✝¹ : Semiring α
inst✝ : Fintype n
M : Matrix n n α
x✝ : M ∈ Set.range ⇑(scalar n)
i j : n
r : α
hr : (scalar n) r = M
⊢ r • stdBasisMatrix i j 1 = MulOpposite.op r • stdBasisMatrix i j 1

tactic: simp
state_before: l : Type u_1
m : Type u_2
n : Type u_3
R : Type u_4
α : Type u_5
inst✝⁴ : DecidableEq l
inst✝³ : DecidableEq m
inst✝² : DecidableEq n
inst✝¹ : Semiring α
inst✝ : Fintype n
M : Matrix n n α
x✝ : M ∈ Set.range ⇑(scalar n)
i j : n
r : α
hr : (scalar n) r = M
⊢ r • stdBasisMatrix i j 1 = MulOpposite.op r • stdBasisMatrix i j 1
state_after: no goals
Theorem: Nat.multinomial_congr
File: Mathlib/Data/Nat/Choose/Multinomial.lean

tactic: simp only [multinomial]
state_before: α : Type u_1
s : Finset α
f✝ : α → ℕ
a b : α
n : ℕ
f g : α → ℕ
h : ∀ a ∈ s, f a = g a
⊢ multinomial s f = multinomial s g
state_after: α : Type u_1
s : Finset α
f✝ : α → ℕ
a b : α
n : ℕ
f g : α → ℕ
h : ∀ a ∈ s, f a = g a
⊢ (∑ i ∈ s, f i)! / ∏ i ∈ s, (f i)! = (∑ i ∈ s, g i)! / ∏ i ∈ s, (g i)!

tactic: congr 1
state_before: α : Type u_1
s : Finset α
f✝ : α → ℕ
a b : α
n : ℕ
f g : α → ℕ
h : ∀ a ∈ s, f a = g a
⊢ (∑ i ∈ s, f i)! / ∏ i ∈ s, (f i)! = (∑ i ∈ s, g i)! / ∏ i ∈ s, (g i)!
state_after: case e_a
α : Type u_1
s : Finset α
f✝ : α → ℕ
a b : α
n : ℕ
f g : α → ℕ
h : ∀ a ∈ s, f a = g a
⊢ (∑ i ∈ s, f i)! = (∑ i ∈ s, g i)!

case e_a
α : Type u_1
s : Finset α
f✝ : α → ℕ
a b : α
n : ℕ
f g : α → ℕ
h : ∀ a ∈ s, f a = g a
⊢ ∏ i ∈ s, (f i)! = ∏ i ∈ s, (g i)!

tactic: rw [Finset.sum_congr rfl h]
state_before: case e_a
α : Type u_1
s : Finset α
f✝ : α → ℕ
a b : α
n : ℕ
f g : α → ℕ
h : ∀ a ∈ s, f a = g a
⊢ (∑ i ∈ s, f i)! = (∑ i ∈ s, g i)!
state_after: no goals

tactic: exact Finset.prod_congr rfl fun a ha => by rw [h a ha]
state_before: case e_a
α : Type u_1
s : Finset α
f✝ : α → ℕ
a b : α
n : ℕ
f g : α → ℕ
h : ∀ a ∈ s, f a = g a
⊢ ∏ i ∈ s, (f i)! = ∏ i ∈ s, (g i)!
state_after: no goals

tactic: rw [h a ha]
state_before: α : Type u_1
s : Finset α
f✝ : α → ℕ
a✝ b : α
n : ℕ
f g : α → ℕ
h : ∀ a ∈ s, f a = g a
a : α
ha : a ∈ s
⊢ (f a)! = (g a)!
state_after: no goals
Theorem: CategoryTheory.Arrow.square_to_iso_invert
File: Mathlib/CategoryTheory/Comma/Arrow.lean

tactic: simpa only [Category.assoc] using (Iso.comp_inv_eq p).mpr (Arrow.w_mk_right sq).symm
state_before: T : Type u
inst✝ : Category.{v, u} T
i : Arrow T
X Y : T
p : X ≅ Y
sq : i ⟶ mk p.hom
⊢ i.hom ≫ sq.right ≫ p.inv = sq.left
state_after: no goals
Theorem: List.rotate_eq_self_iff_eq_replicate
File: Mathlib/Data/List/Rotate.lean

tactic: simp
state_before: α : Type u
hα : Nonempty α
⊢ (∀ (n : ℕ), [].rotate n = []) ↔ ∃ a, [] = replicate [].length a
state_after: no goals

tactic: rw [getElem_replicate, ← Option.some_inj, ← getElem?_eq_getElem, ← head?_rotate h₁, h,
  head?_cons]
state_before: α : Type u
hα : Nonempty α
a : α
l : List α
h : ∀ (n : ℕ), (a :: l).rotate n = a :: l
n : ℕ
h₁ : n < (a :: l).length
h₂ : n < (replicate (a :: l).length a).length
⊢ (a :: l)[n] = (replicate (a :: l).length a)[n]
state_after: no goals

tactic: rw [hb, rotate_replicate]
state_before: α : Type u
hα : Nonempty α
a : α
l : List α
x✝ : ∃ a_1, a :: l = replicate (a :: l).length a_1
n : ℕ
b : α
hb : a :: l = replicate (a :: l).length b
⊢ (a :: l).rotate n = a :: l
state_after: no goals
Theorem: Polynomial.nodup_aroots_iff_of_splits
File: Mathlib/FieldTheory/Separable.lean

tactic: rw [← (algebraMap F K).id_comp, ← splits_map_iff] at h
state_before: F : Type u
inst✝² : Field F
K : Type v
inst✝¹ : Field K
inst✝ : Algebra F K
f : F[X]
hf : f ≠ 0
h : Splits (algebraMap F K) f
⊢ (f.aroots K).Nodup ↔ f.Separable
state_after: F : Type u
inst✝² : Field F
K : Type v
inst✝¹ : Field K
inst✝ : Algebra F K
f : F[X]
hf : f ≠ 0
h : Splits (RingHom.id K) (map (algebraMap F K) f)
⊢ (f.aroots K).Nodup ↔ f.Separable

tactic: rw [nodup_roots_iff_of_splits (map_ne_zero hf) h, separable_map]
state_before: F : Type u
inst✝² : Field F
K : Type v
inst✝¹ : Field K
inst✝ : Algebra F K
f : F[X]
hf : f ≠ 0
h : Splits (RingHom.id K) (map (algebraMap F K) f)
⊢ (f.aroots K).Nodup ↔ f.Separable
state_after: no goals
Theorem: Cardinal.max_aleph_eq
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: rcases le_total (aleph o₁) (aleph o₂) with h | h
state_before: o₁ o₂ : Ordinal.{u_1}
⊢ max (aleph o₁) (aleph o₂) = aleph (max o₁ o₂)
state_after: case inl
o₁ o₂ : Ordinal.{u_1}
h : aleph o₁ ≤ aleph o₂
⊢ max (aleph o₁) (aleph o₂) = aleph (max o₁ o₂)

case inr
o₁ o₂ : Ordinal.{u_1}
h : aleph o₂ ≤ aleph o₁
⊢ max (aleph o₁) (aleph o₂) = aleph (max o₁ o₂)

tactic: rw [max_eq_right h, max_eq_right (aleph_le.1 h)]
state_before: case inl
o₁ o₂ : Ordinal.{u_1}
h : aleph o₁ ≤ aleph o₂
⊢ max (aleph o₁) (aleph o₂) = aleph (max o₁ o₂)
state_after: no goals

tactic: rw [max_eq_left h, max_eq_left (aleph_le.1 h)]
state_before: case inr
o₁ o₂ : Ordinal.{u_1}
h : aleph o₂ ≤ aleph o₁
⊢ max (aleph o₁) (aleph o₂) = aleph (max o₁ o₂)
state_after: no goals
Theorem: MeasureTheory.JordanDecomposition.real_smul_negPart_nonneg
File: Mathlib/MeasureTheory/Decomposition/Jordan.lean

tactic: rw [real_smul_def, ← smul_negPart, if_pos hr]
state_before: α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
j : JordanDecomposition α
r : ℝ
hr : 0 ≤ r
⊢ (r • j).negPart = r.toNNReal • j.negPart
state_after: no goals
Theorem: Matrix.lieConj_apply
File: Mathlib/Algebra/Lie/Matrix.lean

tactic: simp [LinearEquiv.conj_apply, Matrix.lieConj, LinearMap.toMatrix'_comp,
  LinearMap.toMatrix'_toLin']
state_before: R : Type u
inst✝² : CommRing R
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
P A : Matrix n n R
h : Invertible P
⊢ (P.lieConj h) A = P * A * P⁻¹
state_after: no goals
Theorem: Real.iSup_mul_of_nonneg
File: Mathlib/Data/Real/Pointwise.lean

tactic: simp only [Real.mul_iSup_of_nonneg ha, mul_comm]
state_before: ι : Sort u_1
α : Type u_2
inst✝ : LinearOrderedField α
r : ℝ
ha : 0 ≤ r
f : ι → ℝ
⊢ (⨆ i, f i) * r = ⨆ i, f i * r
state_after: no goals
Theorem: MeasureTheory.Measure.absolutelyContinuous_smul
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: simp [AbsolutelyContinuous, hc]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
f : α → β
c : ℝ≥0∞
hc : c ≠ 0
⊢ μ ≪ c • μ
state_after: no goals
Theorem: Nat.pair_lt_max_add_one_sq
File: Mathlib/Data/Nat/Pairing.lean

tactic: simp only [pair, Nat.pow_two, Nat.mul_add, Nat.add_mul, Nat.mul_one, Nat.one_mul, Nat.add_assoc]
state_before: m n : ℕ
⊢ pair m n < (max m n + 1) ^ 2
state_after: m n : ℕ
⊢ (if m < n then n * n + m else m * m + (m + n)) < max m n * max m n + (max m n + (max m n + 1))

tactic: split_ifs <;> simp [Nat.max_eq_left, Nat.max_eq_right, Nat.le_of_lt,  not_lt.1, *] <;> omega
state_before: m n : ℕ
⊢ (if m < n then n * n + m else m * m + (m + n)) < max m n * max m n + (max m n + (max m n + 1))
state_after: no goals
Theorem: Filter.sup_neBot
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [neBot_iff, not_and_or, Ne, sup_eq_bot_iff]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g✝ : Filter α
s t : Set α
f g : Filter α
⊢ (f ⊔ g).NeBot ↔ f.NeBot ∨ g.NeBot
state_after: no goals
Theorem: Polynomial.mirror_mirror
File: Mathlib/Algebra/Polynomial/Mirror.lean

tactic: rw [coeff_mirror, coeff_mirror, mirror_natDegree, mirror_natTrailingDegree, revAt_invol]
state_before: R : Type u_1
inst✝ : Semiring R
p q : R[X]
n : ℕ
⊢ p.mirror.mirror.coeff n = p.coeff n
state_after: no goals
Theorem: List.ofFn_get
File: Mathlib/Data/List/OfFn.lean

tactic: rw [ofFn_zero]
state_before: α : Type u
⊢ ofFn [].get = []
state_after: no goals

tactic: rw [ofFn_succ]
state_before: α : Type u
a : α
l : List α
⊢ ofFn (a :: l).get = a :: l
state_after: α : Type u
a : α
l : List α
⊢ ((a :: l).get 0 :: ofFn fun i => (a :: l).get i.succ) = a :: l

tactic: congr
state_before: α : Type u
a : α
l : List α
⊢ ((a :: l).get 0 :: ofFn fun i => (a :: l).get i.succ) = a :: l
state_after: case e_tail
α : Type u
a : α
l : List α
⊢ (ofFn fun i => (a :: l).get i.succ) = l

tactic: exact ofFn_get l
state_before: case e_tail
α : Type u
a : α
l : List α
⊢ (ofFn fun i => (a :: l).get i.succ) = l
state_after: no goals
Theorem: ArithmeticFunction.IsMultiplicative.prodPrimeFactors
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: rw [iff_ne_zero]
state_before: R : Type u_1
inst✝ : CommMonoidWithZero R
f : ℕ → R
⊢ (ArithmeticFunction.prodPrimeFactors f).IsMultiplicative
state_after: R : Type u_1
inst✝ : CommMonoidWithZero R
f : ℕ → R
⊢ (ArithmeticFunction.prodPrimeFactors f) 1 = 1 ∧
    ∀ {m n : ℕ},
      m ≠ 0 →
        n ≠ 0 →
          m.Coprime n →
            (ArithmeticFunction.prodPrimeFactors f) (m * n) =
              (ArithmeticFunction.prodPrimeFactors f) m * (ArithmeticFunction.prodPrimeFactors f) n

tactic: simp only [ne_eq, one_ne_zero, not_false_eq_true, prodPrimeFactors_apply, primeFactors_one,
  prod_empty, true_and]
state_before: R : Type u_1
inst✝ : CommMonoidWithZero R
f : ℕ → R
⊢ (ArithmeticFunction.prodPrimeFactors f) 1 = 1 ∧
    ∀ {m n : ℕ},
      m ≠ 0 →
        n ≠ 0 →
          m.Coprime n →
            (ArithmeticFunction.prodPrimeFactors f) (m * n) =
              (ArithmeticFunction.prodPrimeFactors f) m * (ArithmeticFunction.prodPrimeFactors f) n
state_after: R : Type u_1
inst✝ : CommMonoidWithZero R
f : ℕ → R
⊢ ∀ {m n : ℕ},
    ¬m = 0 →
      ¬n = 0 →
        m.Coprime n →
          (ArithmeticFunction.prodPrimeFactors f) (m * n) =
            (ArithmeticFunction.prodPrimeFactors f) m * (ArithmeticFunction.prodPrimeFactors f) n

tactic: intro x y hx hy hxy
state_before: R : Type u_1
inst✝ : CommMonoidWithZero R
f : ℕ → R
⊢ ∀ {m n : ℕ},
    ¬m = 0 →
      ¬n = 0 →
        m.Coprime n →
          (ArithmeticFunction.prodPrimeFactors f) (m * n) =
            (ArithmeticFunction.prodPrimeFactors f) m * (ArithmeticFunction.prodPrimeFactors f) n
state_after: R : Type u_1
inst✝ : CommMonoidWithZero R
f : ℕ → R
x y : ℕ
hx : ¬x = 0
hy : ¬y = 0
hxy : x.Coprime y
⊢ (ArithmeticFunction.prodPrimeFactors f) (x * y) =
    (ArithmeticFunction.prodPrimeFactors f) x * (ArithmeticFunction.prodPrimeFactors f) y

tactic: have hxy₀ : x * y ≠ 0 := mul_ne_zero hx hy
state_before: R : Type u_1
inst✝ : CommMonoidWithZero R
f : ℕ → R
x y : ℕ
hx : ¬x = 0
hy : ¬y = 0
hxy : x.Coprime y
⊢ (ArithmeticFunction.prodPrimeFactors f) (x * y) =
    (ArithmeticFunction.prodPrimeFactors f) x * (ArithmeticFunction.prodPrimeFactors f) y
state_after: R : Type u_1
inst✝ : CommMonoidWithZero R
f : ℕ → R
x y : ℕ
hx : ¬x = 0
hy : ¬y = 0
hxy : x.Coprime y
hxy₀ : x * y ≠ 0
⊢ (ArithmeticFunction.prodPrimeFactors f) (x * y) =
    (ArithmeticFunction.prodPrimeFactors f) x * (ArithmeticFunction.prodPrimeFactors f) y

tactic: rw [prodPrimeFactors_apply hxy₀, prodPrimeFactors_apply hx, prodPrimeFactors_apply hy,
  Nat.primeFactors_mul hx hy, ← Finset.prod_union hxy.disjoint_primeFactors]
state_before: R : Type u_1
inst✝ : CommMonoidWithZero R
f : ℕ → R
x y : ℕ
hx : ¬x = 0
hy : ¬y = 0
hxy : x.Coprime y
hxy₀ : x * y ≠ 0
⊢ (ArithmeticFunction.prodPrimeFactors f) (x * y) =
    (ArithmeticFunction.prodPrimeFactors f) x * (ArithmeticFunction.prodPrimeFactors f) y
state_after: no goals
Theorem: Subalgebra.fg_of_submodule_fg
File: Mathlib/RingTheory/Adjoin/FG.lean

tactic: rw [Algebra.top_toSubmodule, eq_top_iff, ← hs, span_le]
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
h : ⊤.FG
s : Finset A
hs : span R ↑s = ⊤
⊢ toSubmodule (Algebra.adjoin R ↑s) = toSubmodule ⊤
state_after: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
h : ⊤.FG
s : Finset A
hs : span R ↑s = ⊤
⊢ ↑s ⊆ ↑(toSubmodule (Algebra.adjoin R ↑s))

tactic: exact Algebra.subset_adjoin
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
h : ⊤.FG
s : Finset A
hs : span R ↑s = ⊤
⊢ ↑s ⊆ ↑(toSubmodule (Algebra.adjoin R ↑s))
state_after: no goals
Theorem: Valuation.map_sub_le
File: Mathlib/RingTheory/Valuation/Basic.lean

tactic: rw [sub_eq_add_neg]
state_before: K : Type u_1
F : Type u_2
R : Type u_3
inst✝³ : DivisionRing K
Γ₀ : Type u_4
Γ'₀ : Type u_5
Γ''₀ : Type u_6
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : Ring R
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
x✝ y✝ z x y : R
g : Γ₀
hx : v x ≤ g
hy : v y ≤ g
⊢ v (x - y) ≤ g
state_after: K : Type u_1
F : Type u_2
R : Type u_3
inst✝³ : DivisionRing K
Γ₀ : Type u_4
Γ'₀ : Type u_5
Γ''₀ : Type u_6
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : Ring R
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
x✝ y✝ z x y : R
g : Γ₀
hx : v x ≤ g
hy : v y ≤ g
⊢ v (x + -y) ≤ g

tactic: exact v.map_add_le hx (le_trans (le_of_eq (v.map_neg y)) hy)
state_before: K : Type u_1
F : Type u_2
R : Type u_3
inst✝³ : DivisionRing K
Γ₀ : Type u_4
Γ'₀ : Type u_5
Γ''₀ : Type u_6
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : Ring R
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
x✝ y✝ z x y : R
g : Γ₀
hx : v x ≤ g
hy : v y ≤ g
⊢ v (x + -y) ≤ g
state_after: no goals
Theorem: Finsupp.prod_filter_mul_prod_filter_not
File: Mathlib/Data/Finsupp/Basic.lean

tactic: classical simp_rw [prod_filter_index, support_filter, Finset.prod_filter_mul_prod_filter_not,
  Finsupp.prod]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝² : Zero M
p : α → Prop
inst✝¹ : DecidablePred p
f : α →₀ M
inst✝ : CommMonoid N
g : α → M → N
⊢ (filter p f).prod g * (filter (fun a => ¬p a) f).prod g = f.prod g
state_after: no goals

tactic: simp_rw [prod_filter_index, support_filter, Finset.prod_filter_mul_prod_filter_not,
Finsupp.prod]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝² : Zero M
p : α → Prop
inst✝¹ : DecidablePred p
f : α →₀ M
inst✝ : CommMonoid N
g : α → M → N
⊢ (filter p f).prod g * (filter (fun a => ¬p a) f).prod g = f.prod g
state_after: no goals
Theorem: lowerClosure_mul_distrib
File: Mathlib/Algebra/Order/UpperLower.lean

tactic: rw [LowerSet.coe_mul, mul_lowerClosure, lowerClosure_mul, LowerSet.lowerClosure]
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
s t : Set α
a : α
⊢ ↑(lowerClosure (s * t)) = ↑(lowerClosure s * lowerClosure t)
state_after: no goals
Theorem: Mathlib.Tactic.Abel.term_smulg
File: Mathlib/Tactic/Abel.lean

tactic: simp [h₂.symm, h₁.symm, termg, smulg, zsmul_add, mul_zsmul]
state_before: α : Type u_1
inst✝ : AddCommGroup α
c n : ℤ
x a : α
n' : ℤ
a' : α
h₁ : c * n = n'
h₂ : smulg c a = a'
⊢ smulg c (termg n x a) = termg n' x a'
state_after: no goals
Theorem: PNat.dvd_iff'
File: Mathlib/Data/PNat/Basic.lean

tactic: rw [dvd_iff]
state_before: k m : ℕ+
⊢ k ∣ m ↔ m.mod k = k
state_after: k m : ℕ+
⊢ ↑k ∣ ↑m ↔ m.mod k = k

tactic: rw [Nat.dvd_iff_mod_eq_zero]
state_before: k m : ℕ+
⊢ ↑k ∣ ↑m ↔ m.mod k = k
state_after: k m : ℕ+
⊢ ↑m % ↑k = 0 ↔ m.mod k = k

tactic: constructor
state_before: k m : ℕ+
⊢ ↑m % ↑k = 0 ↔ m.mod k = k
state_after: case mp
k m : ℕ+
⊢ ↑m % ↑k = 0 → m.mod k = k

case mpr
k m : ℕ+
⊢ m.mod k = k → ↑m % ↑k = 0

tactic: intro h
state_before: case mp
k m : ℕ+
⊢ ↑m % ↑k = 0 → m.mod k = k
state_after: case mp
k m : ℕ+
h : ↑m % ↑k = 0
⊢ m.mod k = k

tactic: apply PNat.eq
state_before: case mp
k m : ℕ+
h : ↑m % ↑k = 0
⊢ m.mod k = k
state_after: case mp.a
k m : ℕ+
h : ↑m % ↑k = 0
⊢ ↑(m.mod k) = ↑k

tactic: rw [mod_coe, if_pos h]
state_before: case mp.a
k m : ℕ+
h : ↑m % ↑k = 0
⊢ ↑(m.mod k) = ↑k
state_after: no goals

tactic: intro h
state_before: case mpr
k m : ℕ+
⊢ m.mod k = k → ↑m % ↑k = 0
state_after: case mpr
k m : ℕ+
h : m.mod k = k
⊢ ↑m % ↑k = 0

tactic: by_cases h' : (m : ℕ) % (k : ℕ) = 0
state_before: case mpr
k m : ℕ+
h : m.mod k = k
⊢ ↑m % ↑k = 0
state_after: case pos
k m : ℕ+
h : m.mod k = k
h' : ↑m % ↑k = 0
⊢ ↑m % ↑k = 0

case neg
k m : ℕ+
h : m.mod k = k
h' : ¬↑m % ↑k = 0
⊢ ↑m % ↑k = 0

tactic: exact h'
state_before: case pos
k m : ℕ+
h : m.mod k = k
h' : ↑m % ↑k = 0
⊢ ↑m % ↑k = 0
state_after: no goals

tactic: replace h : (mod m k : ℕ) = (k : ℕ) := congr_arg _ h
state_before: case neg
k m : ℕ+
h : m.mod k = k
h' : ¬↑m % ↑k = 0
⊢ ↑m % ↑k = 0
state_after: case neg
k m : ℕ+
h' : ¬↑m % ↑k = 0
h : ↑(m.mod k) = ↑k
⊢ ↑m % ↑k = 0

tactic: rw [mod_coe, if_neg h'] at h
state_before: case neg
k m : ℕ+
h' : ¬↑m % ↑k = 0
h : ↑(m.mod k) = ↑k
⊢ ↑m % ↑k = 0
state_after: case neg
k m : ℕ+
h' : ¬↑m % ↑k = 0
h : ↑m % ↑k = ↑k
⊢ ↑m % ↑k = 0

tactic: exact ((Nat.mod_lt (m : ℕ) k.pos).ne h).elim
state_before: case neg
k m : ℕ+
h' : ¬↑m % ↑k = 0
h : ↑m % ↑k = ↑k
⊢ ↑m % ↑k = 0
state_after: no goals
Theorem: ENNReal.le_inv_iff_le_inv
File: Mathlib/Data/ENNReal/Inv.lean

tactic: simpa only [inv_inv] using @ENNReal.inv_le_inv a⁻¹ b
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ a ≤ b⁻¹ ↔ b ≤ a⁻¹
state_after: no goals
Theorem: ProbabilityTheory.IdentDistrib.integrable_snd
File: Mathlib/Probability/IdentDistrib.lean

tactic: rw [← memℒp_one_iff_integrable] at hf ⊢
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : MeasurableSpace α
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace γ
inst✝² : MeasurableSpace δ
μ : Measure α
ν : Measure β
f : α → γ
g : β → γ
inst✝¹ : NormedAddCommGroup γ
inst✝ : BorelSpace γ
h : IdentDistrib f g μ ν
hf : Integrable f μ
⊢ Integrable g ν
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : MeasurableSpace α
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace γ
inst✝² : MeasurableSpace δ
μ : Measure α
ν : Measure β
f : α → γ
g : β → γ
inst✝¹ : NormedAddCommGroup γ
inst✝ : BorelSpace γ
h : IdentDistrib f g μ ν
hf : Memℒp f 1 μ
⊢ Memℒp g 1 ν

tactic: exact h.memℒp_snd hf
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : MeasurableSpace α
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace γ
inst✝² : MeasurableSpace δ
μ : Measure α
ν : Measure β
f : α → γ
g : β → γ
inst✝¹ : NormedAddCommGroup γ
inst✝ : BorelSpace γ
h : IdentDistrib f g μ ν
hf : Memℒp f 1 μ
⊢ Memℒp g 1 ν
state_after: no goals
Theorem: quasispectrumRestricts_iff_spectrumRestricts_inr
File: Mathlib/Algebra/Algebra/Quasispectrum.lean

tactic: rw [quasispectrumRestricts_iff, spectrumRestricts_iff,
  ← Unitization.quasispectrum_eq_spectrum_inr']
state_before: R✝ : Type u_1
A✝ : Type u_2
inst✝¹³ : CommSemiring R✝
inst✝¹² : NonUnitalRing A✝
inst✝¹¹ : Module R✝ A✝
inst✝¹⁰ : IsScalarTower R✝ A✝ A✝
inst✝⁹ : SMulCommClass R✝ A✝ A✝
S : Type u_3
R : Type u_4
A : Type u_5
inst✝⁸ : Semifield R
inst✝⁷ : Field S
inst✝⁶ : NonUnitalRing A
inst✝⁵ : Algebra R S
inst✝⁴ : Module R A
inst✝³ : Module S A
inst✝² : IsScalarTower S A A
inst✝¹ : SMulCommClass S A A
inst✝ : IsScalarTower R S A
a : A
f : S → R
⊢ QuasispectrumRestricts a f ↔ SpectrumRestricts (↑a) f
state_after: no goals
Theorem: tendsto_one_div_add_atTop_nhds_zero_nat
File: Mathlib/Analysis/SpecificLimits/Basic.lean

tactic: simpa
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
this : Tendsto (fun n => 1 / ↑(n + 1)) atTop (𝓝 0)
⊢ Tendsto (fun n => 1 / (↑n + 1)) atTop (𝓝 0)
state_after: no goals
Theorem: BoxIntegral.Prepartition.isPartition_iff_iUnion_eq
File: Mathlib/Analysis/BoxIntegral/Partition/Basic.lean

tactic: simp_rw [IsPartition, Set.Subset.antisymm_iff, π.iUnion_subset, true_and_iff, Set.subset_def,
  mem_iUnion, Box.mem_coe]
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π✝ π₁ π₂ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
π : Prepartition I
⊢ π.IsPartition ↔ π.iUnion = ↑I
state_after: no goals
Theorem: CategoryTheory.ProjectiveResolution.exact_succ
File: Mathlib/CategoryTheory/Preadditive/ProjectiveResolution.lean

tactic: simp only [prev]
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
Z : C
P : ProjectiveResolution Z
n : ℕ
⊢ (ComplexShape.down ℕ).prev (n + 1) = n + 2
state_after: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
Z : C
P : ProjectiveResolution Z
n : ℕ
⊢ n + 1 + 1 = n + 2

tactic: rfl
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
Z : C
P : ProjectiveResolution Z
n : ℕ
⊢ n + 1 + 1 = n + 2
state_after: no goals

tactic: simp
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
Z : C
P : ProjectiveResolution Z
n : ℕ
⊢ (ComplexShape.down ℕ).next (n + 1) = n
state_after: no goals