tasksource/leandojo huggingface dataset:
Theorem: PrimeSpectrum.sup_vanishingIdeal_le
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

tactic: intro r
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
t t' : Set (PrimeSpectrum R)
⊢ vanishingIdeal t ⊔ vanishingIdeal t' ≤ vanishingIdeal (t ∩ t')

tactic: rw [Submodule.mem_sup, mem_vanishingIdeal]
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
t t' : Set (PrimeSpectrum R)
r : R
⊢ r ∈ vanishingIdeal t ⊔ vanishingIdeal t' → r ∈ vanishingIdeal (t ∩ t')

tactic: rintro ⟨f, hf, g, hg, rfl⟩ x ⟨hxt, hxt'⟩
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
t t' : Set (PrimeSpectrum R)
r : R
⊢ (∃ y, y ∈ vanishingIdeal t ∧ ∃ z, z ∈ vanishingIdeal t' ∧ y + z = r) →
    ∀ (x : PrimeSpectrum R), x ∈ t ∩ t' → r ∈ x.asIdeal

tactic: rw [mem_vanishingIdeal] at hf hg
state_before: case intro.intro.intro.intro.intro
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
t t' : Set (PrimeSpectrum R)
f : R
hf : f ∈ vanishingIdeal t
g : R
hg : g ∈ vanishingIdeal t'
x : PrimeSpectrum R
hxt : x ∈ t
hxt' : x ∈ t'
⊢ f + g ∈ x.asIdeal

tactic: apply Submodule.add_mem <;> solve_by_elim
state_before: case intro.intro.intro.intro.intro
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
t t' : Set (PrimeSpectrum R)
f : R
hf : ∀ (x : PrimeSpectrum R), x ∈ t → f ∈ x.asIdeal
g : R
hg : ∀ (x : PrimeSpectrum R), x ∈ t' → g ∈ x.asIdeal
x : PrimeSpectrum R
hxt : x ∈ t
hxt' : x ∈ t'
⊢ f + g ∈ x.asIdeal
Theorem: Sum.update_elim_inr
File: Mathlib/Data/Sum/Basic.lean

tactic: simp
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type ?u.16302
inst✝¹ : DecidableEq β
inst✝ : DecidableEq (α ⊕ β)
f : α → γ
g : β → γ
i : β
x : γ
⊢ x = Sum.elim f (update g i x) (inr i)

tactic: simp (config := { contextual := true })
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type ?u.16302
inst✝¹ : DecidableEq β
inst✝ : DecidableEq (α ⊕ β)
f : α → γ
g : β → γ
i : β
x : γ
⊢ ∀ (x_1 : α ⊕ β), x_1 ≠ inr i → Sum.elim f g x_1 = Sum.elim f (update g i x) x_1
Theorem: symmDiff_symmDiff_symmDiff_comm
File: Mathlib/Order/SymmDiff.lean

tactic: simp_rw [symmDiff_assoc, symmDiff_left_comm]
state_before: ι : Type ?u.73226
α : Type u_1
β : Type ?u.73232
π : ι → Type ?u.73237
inst✝ : GeneralizedBooleanAlgebra α
a b c d : α
⊢ a ∆ b ∆ (c ∆ d) = a ∆ c ∆ (b ∆ d)
Theorem: Polynomial.coeff_mul_X_pow
File: Mathlib/Data/Polynomial/Coeff.lean

tactic: rw [coeff_mul, sum_eq_single (d, n), coeff_X_pow, if_pos rfl, mul_one]
state_before: R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n d : ℕ
⊢ coeff (p * X ^ n) (d + n) = coeff p d

tactic: rintro ⟨i, j⟩ h1 h2
state_before: case h₀
R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n d : ℕ
⊢ ∀ (b : ℕ × ℕ), b ∈ Nat.antidiagonal (d + n) → b ≠ (d, n) → coeff p b.fst * coeff (X ^ n) b.snd = 0

tactic: rw [coeff_X_pow, if_neg, mul_zero]
state_before: case h₀.mk
R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n d i j : ℕ
h1 : (i, j) ∈ Nat.antidiagonal (d + n)
h2 : (i, j) ≠ (d, n)
⊢ coeff p (i, j).fst * coeff (X ^ n) (i, j).snd = 0

tactic: rintro rfl
state_before: case h₀.mk.hnc
R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n d i j : ℕ
h1 : (i, j) ∈ Nat.antidiagonal (d + n)
h2 : (i, j) ≠ (d, n)
⊢ ¬(i, j).snd = n

tactic: apply h2
state_before: case h₀.mk.hnc
R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
d i j : ℕ
h1 : (i, j) ∈ Nat.antidiagonal (d + (i, j).snd)
h2 : (i, j) ≠ (d, (i, j).snd)
⊢ False

tactic: rw [Nat.mem_antidiagonal, add_right_cancel_iff] at h1
state_before: case h₀.mk.hnc
R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
d i j : ℕ
h1 : (i, j) ∈ Nat.antidiagonal (d + (i, j).snd)
h2 : (i, j) ≠ (d, (i, j).snd)
⊢ (i, j) = (d, (i, j).snd)

tactic: subst h1
state_before: case h₀.mk.hnc
R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
d i j : ℕ
h1 : (i, j).fst = d
h2 : (i, j) ≠ (d, (i, j).snd)
⊢ (i, j) = (d, (i, j).snd)

tactic: rfl
state_before: case h₀.mk.hnc
R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
i j : ℕ
h2 : (i, j) ≠ ((i, j).fst, (i, j).snd)
⊢ (i, j) = ((i, j).fst, (i, j).snd)

tactic: exact fun h1 => (h1 (Nat.mem_antidiagonal.2 rfl)).elim
state_before: case h₁
R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n d : ℕ
⊢ ¬(d, n) ∈ Nat.antidiagonal (d + n) → coeff p (d, n).fst * coeff (X ^ n) (d, n).snd = 0
Theorem: SimpleGraph.Walk.edges_map
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p with
| nil => rfl
| cons _ _ ih =>
  simp only [Walk.map_cons, edges_cons, List.map_cons, Sym2.map_pair_eq, List.cons.injEq,
    true_and, ih]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u v u' v' : V
p : Walk G u v
⊢ edges (Walk.map f p) = List.map (Sym2.map ↑f) (edges p)

tactic: rfl
state_before: case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u v u' v' : V
p : Walk G u v
u✝ : V
⊢ edges (Walk.map f nil) = List.map (Sym2.map ↑f) (edges nil)

tactic: simp only [Walk.map_cons, edges_cons, List.map_cons, Sym2.map_pair_eq, List.cons.injEq,
  true_and, ih]
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u v u' v' : V
p : Walk G u v
u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih : edges (Walk.map f p✝) = List.map (Sym2.map ↑f) (edges p✝)
⊢ edges (Walk.map f (cons h✝ p✝)) = List.map (Sym2.map ↑f) (edges (cons h✝ p✝))
Theorem: Matrix.dotProduct_star_self_eq_zero
File: Mathlib/LinearAlgebra/Matrix/DotProduct.lean

tactic: simp [Function.funext_iff, mul_eq_zero]
state_before: R : Type v
n : Type w
inst✝⁴ : Fintype n
inst✝³ : PartialOrder R
inst✝² : NonUnitalRing R
inst✝¹ : StarOrderedRing R
inst✝ : NoZeroDivisors R
v : n → R
⊢ (∀ (i : n), i ∈ Finset.univ → star (v i) * v i = 0) ↔ v = 0
Theorem: Fin.fin_two_eq_of_eq_zero_iff
File: Mathlib/Data/Fin/Basic.lean

tactic: revert a b
state_before: n m : ℕ
a b : Fin 2
h : a = 0 ↔ b = 0
⊢ a = b

tactic: simp [forall_fin_two]
state_before: n m : ℕ
⊢ ∀ {a b : Fin 2}, (a = 0 ↔ b = 0) → a = b
Theorem: multiplicity.Nat.pow_add_pow
File: Mathlib/NumberTheory/Multiplicity.lean

tactic: iterate 2 rw [← Int.coe_nat_multiplicity]
state_before: R : Type ?u.840239
n✝ : ℕ
inst✝ : CommRing R
a b x✝ y✝ : R
p : ℕ
hp : Nat.Prime p
hp1 : Odd p
x y : ℕ
hxy : p ∣ x + y
hx : ¬p ∣ x
n : ℕ
hn : Odd n
⊢ multiplicity p (x ^ n + y ^ n) = multiplicity p (x + y) + multiplicity p n

tactic: rw [← Int.coe_nat_dvd] at hxy hx
state_before: R : Type ?u.840239
n✝ : ℕ
inst✝ : CommRing R
a b x✝ y✝ : R
p : ℕ
hp : Nat.Prime p
hp1 : Odd p
x y : ℕ
hxy : p ∣ x + y
hx : ¬p ∣ x
n : ℕ
hn : Odd n
⊢ multiplicity ↑p ↑(x ^ n + y ^ n) = multiplicity ↑p ↑(x + y) + multiplicity p n

tactic: push_cast at *
state_before: R : Type ?u.840239
n✝ : ℕ
inst✝ : CommRing R
a b x✝ y✝ : R
p : ℕ
hp : Nat.Prime p
hp1 : Odd p
x y : ℕ
hxy : ↑p ∣ ↑(x + y)
hx : ¬↑p ∣ ↑x
n : ℕ
hn : Odd n
⊢ multiplicity ↑p ↑(x ^ n + y ^ n) = multiplicity ↑p ↑(x + y) + multiplicity p n

tactic: exact Int.pow_add_pow hp hp1 hxy hx hn
state_before: R : Type ?u.840239
n✝ : ℕ
inst✝ : CommRing R
a b x✝ y✝ : R
p : ℕ
hp : Nat.Prime p
hp1 : Odd p
x y : ℕ
hx : ¬↑p ∣ ↑x
n : ℕ
hn : Odd n
hxy : ↑p ∣ ↑x + ↑y
⊢ multiplicity (↑p) (↑x ^ n + ↑y ^ n) = multiplicity (↑p) (↑x + ↑y) + multiplicity p n

tactic: rw [← Int.coe_nat_multiplicity]
state_before: R : Type ?u.840239
n✝ : ℕ
inst✝ : CommRing R
a b x✝ y✝ : R
p : ℕ
hp : Nat.Prime p
hp1 : Odd p
x y : ℕ
hxy : p ∣ x + y
hx : ¬p ∣ x
n : ℕ
hn : Odd n
⊢ multiplicity ↑p ↑(x ^ n + y ^ n) = multiplicity p (x + y) + multiplicity p n
Theorem: MonoidHom.map_sub_swap
File: Mathlib/Algebra/GroupPower/Order.lean

tactic: rw [← map_neg, neg_sub]
state_before: β : Type ?u.300600
A : Type ?u.300603
G : Type ?u.300606
M : Type u_1
R : Type u_2
inst✝³ : Ring R
inst✝² : Monoid M
inst✝¹ : LinearOrder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
f : R →* M
x y : R
⊢ ↑f (x - y) = ↑f (y - x)
Theorem: LinearMap.toMatrix₂_compl₂
File: Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean

tactic: rw [← LinearMap.comp_id B, ← LinearMap.compl₁₂, LinearMap.toMatrix₂_compl₁₂ b₁ b₂]
state_before: R : Type u_1
R₁ : Type ?u.1647539
R₂ : Type ?u.1647542
M : Type ?u.1647545
M₁ : Type u_2
M₂ : Type u_3
M₁' : Type ?u.1647554
M₂' : Type u_4
n : Type u_5
m : Type u_7
n' : Type ?u.1647566
m' : Type u_6
ι : Type ?u.1647572
inst✝¹⁶ : CommRing R
inst✝¹⁵ : AddCommMonoid M₁
inst✝¹⁴ : Module R M₁
inst✝¹³ : AddCommMonoid M₂
inst✝¹² : Module R M₂
inst✝¹¹ : DecidableEq n
inst✝¹⁰ : Fintype n
inst✝⁹ : DecidableEq m
inst✝⁸ : Fintype m
b₁ : Basis n R M₁
b₂ : Basis m R M₂
inst✝⁷ : AddCommMonoid M₁'
inst✝⁶ : Module R M₁'
inst✝⁵ : AddCommMonoid M₂'
inst✝⁴ : Module R M₂'
b₁' : Basis n' R M₁'
b₂' : Basis m' R M₂'
inst✝³ : Fintype n'
inst✝² : Fintype m'
inst✝¹ : DecidableEq n'
inst✝ : DecidableEq m'
B : M₁ →ₗ[R] M₂ →ₗ[R] R
f : M₂' →ₗ[R] M₂
⊢ ↑(toMatrix₂ b₁ b₂') (compl₂ B f) = ↑(toMatrix₂ b₁ b₂) B ⬝ ↑(toMatrix b₂' b₂) f

tactic: simp
state_before: R : Type u_1
R₁ : Type ?u.1647539
R₂ : Type ?u.1647542
M : Type ?u.1647545
M₁ : Type u_2
M₂ : Type u_3
M₁' : Type ?u.1647554
M₂' : Type u_4
n : Type u_5
m : Type u_7
n' : Type ?u.1647566
m' : Type u_6
ι : Type ?u.1647572
inst✝¹⁶ : CommRing R
inst✝¹⁵ : AddCommMonoid M₁
inst✝¹⁴ : Module R M₁
inst✝¹³ : AddCommMonoid M₂
inst✝¹² : Module R M₂
inst✝¹¹ : DecidableEq n
inst✝¹⁰ : Fintype n
inst✝⁹ : DecidableEq m
inst✝⁸ : Fintype m
b₁ : Basis n R M₁
b₂ : Basis m R M₂
inst✝⁷ : AddCommMonoid M₁'
inst✝⁶ : Module R M₁'
inst✝⁵ : AddCommMonoid M₂'
inst✝⁴ : Module R M₂'
b₁' : Basis n' R M₁'
b₂' : Basis m' R M₂'
inst✝³ : Fintype n'
inst✝² : Fintype m'
inst✝¹ : DecidableEq n'
inst✝ : DecidableEq m'
B : M₁ →ₗ[R] M₂ →ₗ[R] R
f : M₂' →ₗ[R] M₂
⊢ (↑(toMatrix b₁ b₁) id)ᵀ ⬝ ↑(toMatrix₂ b₁ b₂) B ⬝ ↑(toMatrix b₂' b₂) f =
    ↑(toMatrix₂ b₁ b₂) (comp B id) ⬝ ↑(toMatrix b₂' b₂) f
Theorem: Submodule.mul_annihilator
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: rw [mul_comm, annihilator_mul]
state_before: R : Type u
M : Type v
F : Type ?u.61436
G : Type ?u.61439
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
I✝ J : Ideal R
N P : Submodule R M
I : Ideal R
⊢ I * annihilator I = ⊥
Theorem: CategoryTheory.image_ι_op_comp_imageUnopOp_hom
File: Mathlib/CategoryTheory/Abelian/Opposite.lean

tactic: simp only [imageUnopOp, Iso.trans, Iso.symm, Iso.op, cokernelOpOp_inv, cokernelEpiComp_hom,
  cokernelCompIsIso_hom, Abelian.coimageIsoImage'_hom, ← Category.assoc, ← op_comp]
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
A B : Cᵒᵖ
g : A ⟶ B
⊢ (image.ι g.unop).op ≫ (imageUnopOp g).hom = factorThruImage g

tactic: simp only [Category.assoc, Abelian.imageIsoImage_hom_comp_image_ι, kernel.lift_ι,
  Quiver.Hom.op_unop, cokernelIsoOfEq_hom_comp_desc_assoc, cokernel.π_desc_assoc,
  cokernel.π_desc]
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
A B : Cᵒᵖ
g : A ⟶ B
⊢ (((((kernel.lift (cokernel.π g.unop) (cokernel.π (cokernel.π g.unop).op).unop
                    (_ : (cokernel.π (cokernel.π g.unop).op).unop ≫ cokernel.π g.unop = 0) ≫
                  (Abelian.imageIsoImage g.unop).hom) ≫
                image.ι g.unop).op ≫
            (cokernelIsoOfEq
                (_ : (cokernel.π g.unop).op = (cokernelUnopOp g).hom ≫ kernel.ι g ≫ eqToHom (_ : A = A.unop.op))).hom) ≫
          cokernel.desc ((cokernelUnopOp g).hom ≫ kernel.ι g ≫ eqToHom (_ : A = A.unop.op))
            (cokernel.π (kernel.ι g ≫ eqToHom (_ : A = A.unop.op)))
            (_ :
              ((cokernelUnopOp g).hom ≫ kernel.ι g ≫ eqToHom (_ : A = A.unop.op)) ≫
                  cokernel.π (kernel.ι g ≫ eqToHom (_ : A = A.unop.op)) =
                0)) ≫
        cokernel.desc (kernel.ι g ≫ eqToHom (_ : A = A.unop.op))
          (inv (eqToHom (_ : A = A.unop.op)) ≫ cokernel.π (kernel.ι g))
          (_ :
            (kernel.ι g ≫ eqToHom (_ : A = A.unop.op)) ≫ inv (eqToHom (_ : A = A.unop.op)) ≫ cokernel.π (kernel.ι g) =
              0)) ≫
      cokernel.desc (kernel.ι g) (factorThruImage g) (_ : kernel.ι g ≫ factorThruImage g = 0) =
    factorThruImage g

tactic: simp only [eqToHom_refl]
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
A B : Cᵒᵖ
g : A ⟶ B
⊢ inv (eqToHom (_ : A = A.unop.op)) ≫ factorThruImage g = factorThruImage g

tactic: erw [IsIso.inv_id, Category.id_comp]
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
A B : Cᵒᵖ
g : A ⟶ B
⊢ inv (𝟙 A) ≫ factorThruImage g = factorThruImage g
Theorem: padicNorm.one
File: Mathlib/NumberTheory/Padics/PadicNorm.lean

tactic: simp [padicNorm]
state_before: p : ℕ
⊢ padicNorm p 1 = 1
Theorem: Real.log_mul
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: rw [exp_log_eq_abs (mul_ne_zero hx hy), exp_add, exp_log_eq_abs hx, exp_log_eq_abs hy, abs_mul]
state_before: x y : ℝ
hx : x ≠ 0
hy : y ≠ 0
⊢ exp (log (x * y)) = exp (log x + log y)
Theorem: Set.pairwise_disjoint_Ioc_add_int_cast
File: Mathlib/Data/Set/Intervals/Group.lean

tactic: simpa only [zsmul_one, Int.cast_add, Int.cast_one, ← add_assoc] using
  pairwise_disjoint_Ioc_add_zsmul a (1 : α)
state_before: α : Type u_1
inst✝ : OrderedRing α
a : α
⊢ Pairwise (Disjoint on fun n => Ioc (a + ↑n) (a + ↑n + 1))
Theorem: isModularLattice_iff_inf_sup_inf_assoc
File: Mathlib/Order/ModularLattice.lean

tactic: rw [← inf_eq_left.2 xz, h]
state_before: α : Type u_1
inst✝ : Lattice α
h : ∀ (x y z : α), x ⊓ z ⊔ y ⊓ z = (x ⊓ z ⊔ y) ⊓ z
x✝ y z : α
xz : x✝ ≤ z
⊢ (x✝ ⊔ y) ⊓ z ≤ x✝ ⊔ y ⊓ z
Theorem: Equiv.mul_swap_eq_iff
File: Mathlib/GroupTheory/Perm/Basic.lean

tactic: have swap_id : swap i j = 1 := mul_left_cancel (_root_.trans h (one_mul σ).symm)
state_before: α : Type u
β : Type v
inst✝ : DecidableEq α
i j : α
σ : Perm α
h : σ * swap i j = σ
⊢ i = j

tactic: rw [← swap_apply_right i j, swap_id]
state_before: α : Type u
β : Type v
inst✝ : DecidableEq α
i j : α
σ : Perm α
h : σ * swap i j = σ
swap_id : swap i j = 1
⊢ i = j

tactic: rfl
state_before: α : Type u
β : Type v
inst✝ : DecidableEq α
i j : α
σ : Perm α
h : σ * swap i j = σ
swap_id : swap i j = 1
⊢ ↑1 j = j

tactic: erw [h, swap_self, mul_one]
state_before: α : Type u
β : Type v
inst✝ : DecidableEq α
i j : α
σ : Perm α
h : i = j
⊢ σ * swap i j = σ
Theorem: FractionalIdeal.isNoetherian
File: Mathlib/RingTheory/FractionalIdeal.lean

tactic: obtain ⟨d, J, _, rfl⟩ := exists_eq_spanSingleton_mul I
state_before: R : Type ?u.1863870
inst✝⁷ : CommRing R
S : Submonoid R
P : Type ?u.1864077
inst✝⁶ : CommRing P
inst✝⁵ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_1
inst✝⁴ : CommRing R₁
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R₁ K
frac : IsFractionRing R₁ K
inst✝¹ : IsDomain R₁
inst✝ : IsNoetherianRing R₁
I : FractionalIdeal R₁⁰ K
⊢ IsNoetherian R₁ { x // x ∈ ↑I }

tactic: apply isNoetherian_spanSingleton_inv_to_map_mul
state_before: case intro.intro.intro
R : Type ?u.1863870
inst✝⁷ : CommRing R
S : Submonoid R
P : Type ?u.1864077
inst✝⁶ : CommRing P
inst✝⁵ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_1
inst✝⁴ : CommRing R₁
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R₁ K
frac : IsFractionRing R₁ K
inst✝¹ : IsDomain R₁
inst✝ : IsNoetherianRing R₁
d : R₁
J : Ideal R₁
left✝ : d ≠ 0
⊢ IsNoetherian R₁ { x // x ∈ ↑(spanSingleton R₁⁰ (↑(algebraMap R₁ K) d)⁻¹ * ↑J) }

tactic: apply isNoetherian_coeIdeal
state_before: case intro.intro.intro.hI
R : Type ?u.1863870
inst✝⁷ : CommRing R
S : Submonoid R
P : Type ?u.1864077
inst✝⁶ : CommRing P
inst✝⁵ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_1
inst✝⁴ : CommRing R₁
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R₁ K
frac : IsFractionRing R₁ K
inst✝¹ : IsDomain R₁
inst✝ : IsNoetherianRing R₁
d : R₁
J : Ideal R₁
left✝ : d ≠ 0
⊢ IsNoetherian R₁ { x // x ∈ ↑↑J }
Theorem: sdiff_symmDiff_right
File: Mathlib/Order/SymmDiff.lean

tactic: rw [symmDiff_comm, inf_comm, sdiff_symmDiff_left]
state_before: ι : Type ?u.65700
α : Type u_1
β : Type ?u.65706
π : ι → Type ?u.65711
inst✝ : GeneralizedBooleanAlgebra α
a b c d : α
⊢ b \ a ∆ b = a ⊓ b
Theorem: Dfinsupp.filter_smul
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: ext
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : Monoid γ
inst✝² : (i : ι) → AddMonoid (β i)
inst✝¹ : (i : ι) → DistribMulAction γ (β i)
p : ι → Prop
inst✝ : DecidablePred p
r : γ
f : Π₀ (i : ι), β i
⊢ filter p (r • f) = r • filter p f

tactic: simp [smul_apply, smul_ite]
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : Monoid γ
inst✝² : (i : ι) → AddMonoid (β i)
inst✝¹ : (i : ι) → DistribMulAction γ (β i)
p : ι → Prop
inst✝ : DecidablePred p
r : γ
f : Π₀ (i : ι), β i
i✝ : ι
⊢ ↑(filter p (r • f)) i✝ = ↑(r • filter p f) i✝
Theorem: Matrix.IsDiag.add
File: Mathlib/LinearAlgebra/Matrix/IsDiag.lean

tactic: intro i j h
state_before: α : Type u_1
β : Type ?u.5295
R : Type ?u.5298
n : Type u_2
m : Type ?u.5304
inst✝ : AddZeroClass α
A B : Matrix n n α
ha : IsDiag A
hb : IsDiag B
⊢ IsDiag (A + B)

tactic: simp [ha h, hb h]
state_before: α : Type u_1
β : Type ?u.5295
R : Type ?u.5298
n : Type u_2
m : Type ?u.5304
inst✝ : AddZeroClass α
A B : Matrix n n α
ha : IsDiag A
hb : IsDiag B
i j : n
h : i ≠ j
⊢ (A + B) i j = 0
Theorem: OreLocalization.zero_div_eq_zero
File: Mathlib/RingTheory/OreLocalization/Basic.lean

tactic: rw [OreLocalization.zero_def, oreDiv_eq_iff]
state_before: R : Type u_1
inst✝¹ : Semiring R
S : Submonoid R
inst✝ : OreSet S
s : { x // x ∈ S }
⊢ 0 /ₒ s = 0

tactic: exact ⟨s, 1, by simp⟩
state_before: R : Type u_1
inst✝¹ : Semiring R
S : Submonoid R
inst✝ : OreSet S
s : { x // x ∈ S }
⊢ ∃ u v, 0 * ↑u = 0 * v ∧ ↑1 * ↑u = ↑s * v

tactic: simp
state_before: R : Type u_1
inst✝¹ : Semiring R
S : Submonoid R
inst✝ : OreSet S
s : { x // x ∈ S }
⊢ 0 * ↑s = 0 * 1 ∧ ↑1 * ↑s = ↑s * 1
Theorem: NNReal.summable_sigma
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: constructor
state_before: α : Type u_2
β✝ : Type ?u.316734
γ : Type ?u.316737
β : α → Type u_1
f : (x : α) × β x → ℝ≥0
⊢ Summable f ↔
    (∀ (x : α), Summable fun y => f { fst := x, snd := y }) ∧ Summable fun x => ∑' (y : β x), f { fst := x, snd := y }

tactic: simp only [← NNReal.summable_coe, NNReal.coe_tsum]
state_before: case mp
α : Type u_2
β✝ : Type ?u.316734
γ : Type ?u.316737
β : α → Type u_1
f : (x : α) × β x → ℝ≥0
⊢ Summable f →
    (∀ (x : α), Summable fun y => f { fst := x, snd := y }) ∧ Summable fun x => ∑' (y : β x), f { fst := x, snd := y }

tactic: exact fun h => ⟨h.sigma_factor, h.sigma⟩
state_before: case mp
α : Type u_2
β✝ : Type ?u.316734
γ : Type ?u.316737
β : α → Type u_1
f : (x : α) × β x → ℝ≥0
⊢ (Summable fun a => ↑(f a)) →
    (∀ (x : α), Summable fun a => ↑(f { fst := x, snd := a })) ∧
      Summable fun a => ∑' (a_1 : β a), ↑(f { fst := a, snd := a_1 })

tactic: rintro ⟨h₁, h₂⟩
state_before: case mpr
α : Type u_2
β✝ : Type ?u.316734
γ : Type ?u.316737
β : α → Type u_1
f : (x : α) × β x → ℝ≥0
⊢ ((∀ (x : α), Summable fun y => f { fst := x, snd := y }) ∧ Summable fun x => ∑' (y : β x), f { fst := x, snd := y }) →
    Summable f

tactic: simpa only [← ENNReal.tsum_coe_ne_top_iff_summable, ENNReal.tsum_sigma',
  ENNReal.coe_tsum (h₁ _)] using h₂
state_before: case mpr.intro
α : Type u_2
β✝ : Type ?u.316734
γ : Type ?u.316737
β : α → Type u_1
f : (x : α) × β x → ℝ≥0
h₁ : ∀ (x : α), Summable fun y => f { fst := x, snd := y }
h₂ : Summable fun x => ∑' (y : β x), f { fst := x, snd := y }
⊢ Summable f
Theorem: String.Iterator.forward_eq_nextn
File: Std/Data/String/Lemmas.lean

tactic: funext it n
state_before: ⊢ forward = nextn

tactic: induction n generalizing it <;> simp [forward, nextn, *]
state_before: case h.h
it : Iterator
n : Nat
⊢ forward it n = nextn it n
Theorem: Num.cast_inj
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [← cast_to_nat m, ← cast_to_nat n, Nat.cast_inj, to_nat_inj]
state_before: α : Type u_1
inst✝ : LinearOrderedSemiring α
m n : Num
⊢ ↑m = ↑n ↔ m = n
Theorem: Real.logb_pos
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: rw [logb_pos_iff hb (lt_trans zero_lt_one hx)]
state_before: b x y : ℝ
hb : 1 < b
hx : 1 < x
⊢ 0 < logb b x

tactic: exact hx
state_before: b x y : ℝ
hb : 1 < b
hx : 1 < x
⊢ 1 < x
Theorem: LocalEquiv.IsImage.iff_preimage_eq
File: Mathlib/Logic/Equiv/LocalEquiv.lean

tactic: simp only [IsImage, ext_iff, mem_inter_iff, mem_preimage, and_congr_right_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.27993
δ : Type ?u.27996
e : LocalEquiv α β
e' : LocalEquiv β γ
s : Set α
t : Set β
x : α
y : β
⊢ IsImage e s t ↔ e.source ∩ ↑e ⁻¹' t = e.source ∩ s
Theorem: Equiv.Perm.nodup_of_pairwise_disjoint
File: Mathlib/GroupTheory/Perm/Support.lean

tactic: refine' List.Pairwise.imp_of_mem _ h2
state_before: α : Type u_1
f g h : Perm α
l : List (Perm α)
h1 : ¬1 ∈ l
h2 : List.Pairwise Disjoint l
⊢ List.Nodup l

tactic: intro τ σ h_mem _ h_disjoint _
state_before: α : Type u_1
f g h : Perm α
l : List (Perm α)
h1 : ¬1 ∈ l
h2 : List.Pairwise Disjoint l
⊢ ∀ {a b : Perm α}, a ∈ l → b ∈ l → Disjoint a b → a ≠ b

tactic: subst τ
state_before: α : Type u_1
f g h : Perm α
l : List (Perm α)
h1 : ¬1 ∈ l
h2 : List.Pairwise Disjoint l
τ σ : Perm α
h_mem : τ ∈ l
a✝¹ : σ ∈ l
h_disjoint : Disjoint τ σ
a✝ : τ = σ
⊢ False

tactic: suffices (σ : Perm α) = 1 by
  rw [this] at h_mem
  exact h1 h_mem
state_before: α : Type u_1
f g h : Perm α
l : List (Perm α)
h1 : ¬1 ∈ l
h2 : List.Pairwise Disjoint l
σ : Perm α
a✝ h_mem : σ ∈ l
h_disjoint : Disjoint σ σ
⊢ False

tactic: exact ext fun a => (or_self_iff _).mp (h_disjoint a)
state_before: α : Type u_1
f g h : Perm α
l : List (Perm α)
h1 : ¬1 ∈ l
h2 : List.Pairwise Disjoint l
σ : Perm α
a✝ h_mem : σ ∈ l
h_disjoint : Disjoint σ σ
⊢ σ = 1

tactic: rw [this] at h_mem
state_before: α : Type u_1
f g h : Perm α
l : List (Perm α)
h1 : ¬1 ∈ l
h2 : List.Pairwise Disjoint l
σ : Perm α
a✝ h_mem : σ ∈ l
h_disjoint : Disjoint σ σ
this : σ = 1
⊢ False

tactic: exact h1 h_mem
state_before: α : Type u_1
f g h : Perm α
l : List (Perm α)
h1 : ¬1 ∈ l
h2 : List.Pairwise Disjoint l
σ : Perm α
a✝ : σ ∈ l
h_mem : 1 ∈ l
h_disjoint : Disjoint σ σ
this : σ = 1
⊢ False
Theorem: Asymptotics.IsTheta.tendsto_norm_atTop_iff
File: Mathlib/Analysis/Asymptotics/Theta.lean

tactic: simp only [Function.comp, ← isLittleO_const_left_of_ne (one_ne_zero' ℝ), h.isLittleO_congr_right]
state_before: α : Type u_1
β : Type ?u.35351
E : Type ?u.35354
F : Type ?u.35357
G : Type ?u.35360
E' : Type u_2
F' : Type u_3
G' : Type ?u.35369
E'' : Type ?u.35372
F'' : Type ?u.35375
G'' : Type ?u.35378
R : Type ?u.35381
R' : Type ?u.35384
𝕜 : Type ?u.35387
𝕜' : Type ?u.35390
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
l l' : Filter α
h : f' =Θ[l] g'
⊢ Tendsto (norm ∘ f') l atTop ↔ Tendsto (norm ∘ g') l atTop
Theorem: List.map_coe_finRange
File: Mathlib/Data/List/FinRange.lean

tactic: simp_rw [finRange, map_pmap, pmap_eq_map]
state_before: α : Type u
n : ℕ
⊢ map Fin.val (finRange n) = range n

tactic: exact List.map_id _
state_before: α : Type u
n : ℕ
⊢ map (fun a => a) (range n) = range n
Theorem: Filter.isOpen_setOf_mem
File: Mathlib/Topology/Filter.lean

tactic: simpa only [Iic_principal] using isOpen_Iic_principal
state_before: ι : Sort ?u.385
α : Type u_1
β : Type ?u.391
X : Type ?u.394
Y : Type ?u.397
s : Set α
⊢ IsOpen {l | s ∈ l}