1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: AlgebraicGeometry.SheafedSpace.IsOpenImmersion.inv_invApp
File: Mathlib/Geometry/RingedSpace/OpenImmersion.lean

tactic: simp [Opens.map, Set.preimage_image_eq _ H.base_open.inj]
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : SheafedSpace C
f : X ⟶ Y
H : IsOpenImmersion f
U : Opens ↑↑X.toPresheafedSpace
⊢ (Opens.map f.base).op.obj { unop := (opensFunctor f).obj U } = { unop := U }
state_after: no goals
Theorem: Finset.cast_card
File: Mathlib/Algebra/Module/BigOperators.lean

tactic: rw [Finset.sum_const, Nat.smul_one_eq_cast]
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
s : Finset α
⊢ ↑s.card = ∑ a ∈ s, 1
state_after: no goals
Theorem: TietzeExtension.of_homeo
File: Mathlib/Topology/TietzeExtension.lean

tactic: simp
state_before: X₁ : Type u₁
inst✝⁷ : TopologicalSpace X₁
X : Type u
inst✝⁶ : TopologicalSpace X
inst✝⁵ : NormalSpace X
s : Set X
hs : IsClosed s
e✝ : X₁ → X
he : ClosedEmbedding e✝
Y✝ : Type v
inst✝⁴ : TopologicalSpace Y✝
inst✝³ : TietzeExtension Y✝
Y : Type v
Z : Type w
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : TietzeExtension Z
e : Y ≃ₜ Z
⊢ e.symm.toContinuousMap.comp e.toContinuousMap = ContinuousMap.id Y
state_after: no goals
Theorem: Finset.prod_Ico_succ_top
File: Mathlib/Algebra/BigOperators/Intervals.lean

tactic: rw [Nat.Ico_succ_right_eq_insert_Ico hab, prod_insert right_not_mem_Ico, mul_comm]
state_before: α : Type u_1
M : Type u_2
inst✝ : CommMonoid M
s₂ s₁ s : Finset α
a✝ : α
g f✝ : α → M
a b : ℕ
hab : a ≤ b
f : ℕ → M
⊢ ∏ k ∈ Ico a (b + 1), f k = (∏ k ∈ Ico a b, f k) * f b
state_after: no goals
Theorem: Measurable.setLIntegral_kernel
File: Mathlib/Probability/Kernel/MeasurableIntegral.lean

tactic: refine Measurable.setLIntegral_kernel_prod_right ?_ hs
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
inst✝ : IsSFiniteKernel η
f : β → ℝ≥0∞
hf : Measurable f
s : Set β
hs : MeasurableSet s
⊢ Measurable fun a => ∫⁻ (b : β) in s, f b ∂κ a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
inst✝ : IsSFiniteKernel η
f : β → ℝ≥0∞
hf : Measurable f
s : Set β
hs : MeasurableSet s
⊢ Measurable (uncurry fun a => f)

tactic: convert hf.comp measurable_snd
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
inst✝ : IsSFiniteKernel η
f : β → ℝ≥0∞
hf : Measurable f
s : Set β
hs : MeasurableSet s
⊢ Measurable (uncurry fun a => f)
state_after: no goals
Theorem: linearIndependent_fin_succ'
File: Mathlib/LinearAlgebra/LinearIndependent.lean

tactic: rw [← linearIndependent_fin_snoc, Fin.snoc_init_self]
state_before: ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v✝ : ι → V
s t : Set V
x y z : V
n : ℕ
v : Fin (n + 1) → V
⊢ LinearIndependent K v ↔ LinearIndependent K (Fin.init v) ∧ v (Fin.last n) ∉ span K (range (Fin.init v))
state_after: no goals
Theorem: CliffordAlgebra.commute_map_mul_map_of_isOrtho_of_mem_evenOdd_zero_right
File: Mathlib/LinearAlgebra/CliffordAlgebra/Prod.lean

tactic: simp
state_before: R : Type u_1
M₁ : Type u_2
M₂ : Type u_3
N : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : AddCommGroup M₂
inst✝³ : AddCommGroup N
inst✝² : Module R M₁
inst✝¹ : Module R M₂
inst✝ : Module R N
Q₁ : QuadraticForm R M₁
Q₂ : QuadraticForm R M₂
Qₙ : QuadraticForm R N
f₁ : Q₁ →qᵢ Qₙ
f₂ : Q₂ →qᵢ Qₙ
hf : ∀ (x : M₁) (y : M₂), Qₙ.IsOrtho (f₁ x) (f₂ y)
m₁ : CliffordAlgebra Q₁
m₂ : CliffordAlgebra Q₂
i₁ : ZMod 2
hm₁ : m₁ ∈ evenOdd Q₁ i₁
hm₂ : m₂ ∈ evenOdd Q₂ 0
⊢ (-1) ^ (0 * i₁) • ((map f₂) m₂ * (map f₁) m₁) = (map f₂) m₂ * (map f₁) m₁
state_after: no goals
Theorem: MvPolynomial.degrees_monomial_eq
File: Mathlib/Algebra/MvPolynomial/Degrees.lean

tactic: classical
  exact (supDegree_single s a).trans (if_neg ha)
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s✝ : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
s : σ →₀ ℕ
a : R
ha : a ≠ 0
⊢ ((monomial s) a).degrees = toMultiset s
state_after: no goals

tactic: exact (supDegree_single s a).trans (if_neg ha)
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s✝ : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
s : σ →₀ ℕ
a : R
ha : a ≠ 0
⊢ ((monomial s) a).degrees = toMultiset s
state_after: no goals
Theorem: CategoryTheory.Limits.strongEpi_of_strongEpiMonoFactorisation
File: Mathlib/CategoryTheory/Limits/Shapes/Images.lean

tactic: rw [← IsImage.e_isoExt_hom F.toMonoIsImage hF']
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
F : StrongEpiMonoFactorisation f
F' : MonoFactorisation f
hF' : IsImage F'
⊢ StrongEpi F'.e
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
F : StrongEpiMonoFactorisation f
F' : MonoFactorisation f
hF' : IsImage F'
⊢ StrongEpi (F.e ≫ (F.toMonoIsImage.isoExt hF').hom)

tactic: apply strongEpi_comp
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
F : StrongEpiMonoFactorisation f
F' : MonoFactorisation f
hF' : IsImage F'
⊢ StrongEpi (F.e ≫ (F.toMonoIsImage.isoExt hF').hom)
state_after: no goals
Theorem: Nat.coprime_add_self_right
File: Mathlib/Data/Nat/GCD/Basic.lean

tactic: rw [Coprime, Coprime, gcd_add_self_right]
state_before: m n : ℕ
⊢ m.Coprime (n + m) ↔ m.Coprime n
state_after: no goals
Theorem: Odd.neg_pow
File: Mathlib/Algebra/Ring/Parity.lean

tactic: rintro ⟨c, rfl⟩ a
state_before: F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝¹ : Monoid α
inst✝ : HasDistribNeg α
a : α
n : ℕ
⊢ Odd n → ∀ (a : α), (-a) ^ n = -a ^ n
state_after: case intro
F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝¹ : Monoid α
inst✝ : HasDistribNeg α
a✝ : α
c : ℕ
a : α
⊢ (-a) ^ (2 * c + 1) = -a ^ (2 * c + 1)

tactic: simp_rw [pow_add, pow_mul, neg_sq, pow_one, mul_neg]
state_before: case intro
F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝¹ : Monoid α
inst✝ : HasDistribNeg α
a✝ : α
c : ℕ
a : α
⊢ (-a) ^ (2 * c + 1) = -a ^ (2 * c + 1)
state_after: no goals
Theorem: fourierIntegral_gaussian_pi
File: Mathlib/Analysis/SpecialFunctions/Gaussian/FourierTransform.lean

tactic: simpa only [mul_zero, zero_mul, add_zero] using fourierIntegral_gaussian_pi' hb 0
state_before: b : ℂ
hb : 0 < b.re
⊢ (𝓕 fun x => cexp (-↑π * b * ↑x ^ 2)) = fun t => 1 / b ^ (1 / 2) * cexp (-↑π / b * ↑t ^ 2)
state_after: no goals
Theorem: Hyperreal.st_inv
File: Mathlib/Data/Real/Hyperreal.lean

tactic: by_cases h0 : x = 0
state_before: x : ℝ*
⊢ x⁻¹.st = x.st⁻¹
state_after: case pos
x : ℝ*
h0 : x = 0
⊢ x⁻¹.st = x.st⁻¹

case neg
x : ℝ*
h0 : ¬x = 0
⊢ x⁻¹.st = x.st⁻¹

tactic: by_cases h1 : Infinitesimal x
state_before: case neg
x : ℝ*
h0 : ¬x = 0
⊢ x⁻¹.st = x.st⁻¹
state_after: case pos
x : ℝ*
h0 : ¬x = 0
h1 : x.Infinitesimal
⊢ x⁻¹.st = x.st⁻¹

case neg
x : ℝ*
h0 : ¬x = 0
h1 : ¬x.Infinitesimal
⊢ x⁻¹.st = x.st⁻¹

tactic: by_cases h2 : Infinite x
state_before: case neg
x : ℝ*
h0 : ¬x = 0
h1 : ¬x.Infinitesimal
⊢ x⁻¹.st = x.st⁻¹
state_after: case pos
x : ℝ*
h0 : ¬x = 0
h1 : ¬x.Infinitesimal
h2 : x.Infinite
⊢ x⁻¹.st = x.st⁻¹

case neg
x : ℝ*
h0 : ¬x = 0
h1 : ¬x.Infinitesimal
h2 : ¬x.Infinite
⊢ x⁻¹.st = x.st⁻¹

tactic: exact ((isSt_st' h2).inv h1).st_eq
state_before: case neg
x : ℝ*
h0 : ¬x = 0
h1 : ¬x.Infinitesimal
h2 : ¬x.Infinite
⊢ x⁻¹.st = x.st⁻¹
state_after: no goals

tactic: rw [h0, inv_zero, ← coe_zero, st_id_real, inv_zero]
state_before: case pos
x : ℝ*
h0 : x = 0
⊢ x⁻¹.st = x.st⁻¹
state_after: no goals

tactic: rw [((infinitesimal_iff_infinite_inv h0).mp h1).st_eq, h1.st_eq, inv_zero]
state_before: case pos
x : ℝ*
h0 : ¬x = 0
h1 : x.Infinitesimal
⊢ x⁻¹.st = x.st⁻¹
state_after: no goals

tactic: rw [(infinitesimal_inv_of_infinite h2).st_eq, h2.st_eq, inv_zero]
state_before: case pos
x : ℝ*
h0 : ¬x = 0
h1 : ¬x.Infinitesimal
h2 : x.Infinite
⊢ x⁻¹.st = x.st⁻¹
state_after: no goals
Theorem: Filter.bot_pow
File: Mathlib/Order/Filter/Pointwise.lean

tactic: rw [← tsub_add_cancel_of_le (Nat.succ_le_of_lt <| Nat.pos_of_ne_zero hn), pow_succ', bot_mul]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ε : Type u_6
inst✝ : Monoid α
f g : Filter α
s : Set α
a : α
m n✝ n : ℕ
hn : n ≠ 0
⊢ ⊥ ^ n = ⊥
state_after: no goals
Theorem: tendsto_order_unbounded
File: Mathlib/Topology/Order/Basic.lean

tactic: simp only [nhds_order_unbounded hu hl, tendsto_iInf, tendsto_principal]
state_before: α : Type u
β : Type v
γ : Type w
inst✝¹ : TopologicalSpace α
inst✝ : Preorder α
t : OrderTopology α
f : β → α
a : α
x : Filter β
hu : ∃ u, a < u
hl : ∃ l, l < a
h : ∀ (l u : α), l < a → a < u → ∀ᶠ (b : β) in x, l < f b ∧ f b < u
⊢ Tendsto f x (𝓝 a)
state_after: α : Type u
β : Type v
γ : Type w
inst✝¹ : TopologicalSpace α
inst✝ : Preorder α
t : OrderTopology α
f : β → α
a : α
x : Filter β
hu : ∃ u, a < u
hl : ∃ l, l < a
h : ∀ (l u : α), l < a → a < u → ∀ᶠ (b : β) in x, l < f b ∧ f b < u
⊢ ∀ i < a, ∀ (i_2 : α), a < i_2 → ∀ᶠ (a : β) in x, f a ∈ Ioo i i_2

tactic: exact fun l hl u => h l u hl
state_before: α : Type u
β : Type v
γ : Type w
inst✝¹ : TopologicalSpace α
inst✝ : Preorder α
t : OrderTopology α
f : β → α
a : α
x : Filter β
hu : ∃ u, a < u
hl : ∃ l, l < a
h : ∀ (l u : α), l < a → a < u → ∀ᶠ (b : β) in x, l < f b ∧ f b < u
⊢ ∀ i < a, ∀ (i_2 : α), a < i_2 → ∀ᶠ (a : β) in x, f a ∈ Ioo i i_2
state_after: no goals
Theorem: Matrix.neg_dotProduct
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp [dotProduct]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : Fintype m
inst✝¹ : Fintype n
inst✝ : NonUnitalNonAssocRing α
u v w : m → α
⊢ -v ⬝ᵥ w = -(v ⬝ᵥ w)
state_after: no goals
Theorem: connectedComponentIn_nonempty_iff
File: Mathlib/Topology/Connected/Basic.lean

tactic: rw [connectedComponentIn]
state_before: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s t u v : Set α
x : α
F : Set α
⊢ (connectedComponentIn F x).Nonempty ↔ x ∈ F
state_after: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s t u v : Set α
x : α
F : Set α
⊢ (if h : x ∈ F then Subtype.val '' connectedComponent ⟨x, h⟩ else ∅).Nonempty ↔ x ∈ F

tactic: split_ifs <;> simp [connectedComponent_nonempty, *]
state_before: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s t u v : Set α
x : α
F : Set α
⊢ (if h : x ∈ F then Subtype.val '' connectedComponent ⟨x, h⟩ else ∅).Nonempty ↔ x ∈ F
state_after: no goals
Theorem: HasStrictDerivAt.clog
File: Mathlib/Analysis/SpecialFunctions/Complex/LogDeriv.lean

tactic: rw [div_eq_inv_mul]
state_before: α : Type u_1
inst✝² : TopologicalSpace α
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → ℂ
f' x : ℂ
h₁ : HasStrictDerivAt f f' x
h₂ : f x ∈ slitPlane
⊢ HasStrictDerivAt (fun t => log (f t)) (f' / f x) x
state_after: α : Type u_1
inst✝² : TopologicalSpace α
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → ℂ
f' x : ℂ
h₁ : HasStrictDerivAt f f' x
h₂ : f x ∈ slitPlane
⊢ HasStrictDerivAt (fun t => log (f t)) ((f x)⁻¹ * f') x

tactic: exact (hasStrictDerivAt_log h₂).comp x h₁
state_before: α : Type u_1
inst✝² : TopologicalSpace α
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → ℂ
f' x : ℂ
h₁ : HasStrictDerivAt f f' x
h₂ : f x ∈ slitPlane
⊢ HasStrictDerivAt (fun t => log (f t)) ((f x)⁻¹ * f') x
state_after: no goals
Theorem: SemiconjBy.sub_right
File: Mathlib/Algebra/Ring/Semiconj.lean

tactic: simpa only [sub_eq_add_neg] using h.add_right h'.neg_right
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : NonUnitalNonAssocRing R
a b x y x' y' : R
h : SemiconjBy a x y
h' : SemiconjBy a x' y'
⊢ SemiconjBy a (x - x') (y - y')
state_after: no goals
Theorem: Lists.of_toList
File: Mathlib/SetTheory/Lists.lean

tactic: simp_all [ofList, of']
state_before: α : Type u_1
l : Lists' α true
x✝ : IsList ⟨true, l⟩
⊢ ofList (toList ⟨true, l⟩) = ⟨true, l⟩
state_after: no goals
Theorem: Set.mem_center_iff_addMonoidHom
File: Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean

tactic: rw [Set.mem_center_iff, isMulCentral_iff]
state_before: R : Type u
S : Type v
T : Type w
inst✝³ : NonUnitalNonAssocSemiring R
M : Subsemigroup R
inst✝² : NonUnitalNonAssocSemiring S
inst✝¹ : NonUnitalNonAssocSemiring T
inst✝ : NonUnitalNonAssocSemiring R
a : R
⊢ a ∈ Set.center R ↔
    AddMonoidHom.mulLeft a = AddMonoidHom.mulRight a ∧
      AddMonoidHom.mul.compr₂ (AddMonoidHom.mulLeft a) = AddMonoidHom.mul.comp (AddMonoidHom.mulLeft a) ∧
        AddMonoidHom.mul.comp (AddMonoidHom.mulRight a) = AddMonoidHom.mul.compl₂ (AddMonoidHom.mulLeft a) ∧
          AddMonoidHom.mul.compr₂ (AddMonoidHom.mulRight a) = AddMonoidHom.mul.compl₂ (AddMonoidHom.mulRight a)
state_after: R : Type u
S : Type v
T : Type w
inst✝³ : NonUnitalNonAssocSemiring R
M : Subsemigroup R
inst✝² : NonUnitalNonAssocSemiring S
inst✝¹ : NonUnitalNonAssocSemiring T
inst✝ : NonUnitalNonAssocSemiring R
a : R
⊢ ((∀ (a_1 : R), a * a_1 = a_1 * a) ∧
      (∀ (b c : R), a * (b * c) = a * b * c) ∧
        (∀ (a_1 c : R), a_1 * a * c = a_1 * (a * c)) ∧ ∀ (a_1 b : R), a_1 * b * a = a_1 * (b * a)) ↔
    AddMonoidHom.mulLeft a = AddMonoidHom.mulRight a ∧
      AddMonoidHom.mul.compr₂ (AddMonoidHom.mulLeft a) = AddMonoidHom.mul.comp (AddMonoidHom.mulLeft a) ∧
        AddMonoidHom.mul.comp (AddMonoidHom.mulRight a) = AddMonoidHom.mul.compl₂ (AddMonoidHom.mulLeft a) ∧
          AddMonoidHom.mul.compr₂ (AddMonoidHom.mulRight a) = AddMonoidHom.mul.compl₂ (AddMonoidHom.mulRight a)

tactic: simp [DFunLike.ext_iff]
state_before: R : Type u
S : Type v
T : Type w
inst✝³ : NonUnitalNonAssocSemiring R
M : Subsemigroup R
inst✝² : NonUnitalNonAssocSemiring S
inst✝¹ : NonUnitalNonAssocSemiring T
inst✝ : NonUnitalNonAssocSemiring R
a : R
⊢ ((∀ (a_1 : R), a * a_1 = a_1 * a) ∧
      (∀ (b c : R), a * (b * c) = a * b * c) ∧
        (∀ (a_1 c : R), a_1 * a * c = a_1 * (a * c)) ∧ ∀ (a_1 b : R), a_1 * b * a = a_1 * (b * a)) ↔
    AddMonoidHom.mulLeft a = AddMonoidHom.mulRight a ∧
      AddMonoidHom.mul.compr₂ (AddMonoidHom.mulLeft a) = AddMonoidHom.mul.comp (AddMonoidHom.mulLeft a) ∧
        AddMonoidHom.mul.comp (AddMonoidHom.mulRight a) = AddMonoidHom.mul.compl₂ (AddMonoidHom.mulLeft a) ∧
          AddMonoidHom.mul.compr₂ (AddMonoidHom.mulRight a) = AddMonoidHom.mul.compl₂ (AddMonoidHom.mulRight a)
state_after: no goals
Theorem: Nat.map_div_left_divisors
File: Mathlib/NumberTheory/Divisors.lean

tactic: apply Finset.map_injective (Equiv.prodComm _ _).toEmbedding
state_before: n : ℕ
⊢ map { toFun := fun d => (n / d, d), inj' := ⋯ } n.divisors = n.divisorsAntidiagonal
state_after: case a
n : ℕ
⊢ map (Equiv.prodComm ℕ ℕ).toEmbedding (map { toFun := fun d => (n / d, d), inj' := ⋯ } n.divisors) =
    map (Equiv.prodComm ℕ ℕ).toEmbedding n.divisorsAntidiagonal

tactic: ext
state_before: case a
n : ℕ
⊢ map (Equiv.prodComm ℕ ℕ).toEmbedding (map { toFun := fun d => (n / d, d), inj' := ⋯ } n.divisors) =
    map (Equiv.prodComm ℕ ℕ).toEmbedding n.divisorsAntidiagonal
state_after: case a.a
n : ℕ
a✝ : ℕ × ℕ
⊢ a✝ ∈ map (Equiv.prodComm ℕ ℕ).toEmbedding (map { toFun := fun d => (n / d, d), inj' := ⋯ } n.divisors) ↔
    a✝ ∈ map (Equiv.prodComm ℕ ℕ).toEmbedding n.divisorsAntidiagonal

tactic: rw [map_swap_divisorsAntidiagonal, ← map_div_right_divisors, Finset.map_map]
state_before: case a.a
n : ℕ
a✝ : ℕ × ℕ
⊢ a✝ ∈ map (Equiv.prodComm ℕ ℕ).toEmbedding (map { toFun := fun d => (n / d, d), inj' := ⋯ } n.divisors) ↔
    a✝ ∈ map (Equiv.prodComm ℕ ℕ).toEmbedding n.divisorsAntidiagonal
state_after: case a.a
n : ℕ
a✝ : ℕ × ℕ
⊢ a✝ ∈ map ({ toFun := fun d => (n / d, d), inj' := ⋯ }.trans (Equiv.prodComm ℕ ℕ).toEmbedding) n.divisors ↔
    a✝ ∈ map { toFun := fun d => (d, n / d), inj' := ⋯ } n.divisors

tactic: simp
state_before: case a.a
n : ℕ
a✝ : ℕ × ℕ
⊢ a✝ ∈ map ({ toFun := fun d => (n / d, d), inj' := ⋯ }.trans (Equiv.prodComm ℕ ℕ).toEmbedding) n.divisors ↔
    a✝ ∈ map { toFun := fun d => (d, n / d), inj' := ⋯ } n.divisors
state_after: no goals
Theorem: AlgebraicTopology.DoldKan.homotopyPToId_eventually_constant
File: Mathlib/AlgebraicTopology/DoldKan/HomotopyEquivalence.lean

tactic: simp only [homotopyHσToZero, AlternatingFaceMapComplex.obj_X, Nat.add_eq, Homotopy.trans_hom,
  Homotopy.ofEq_hom, Pi.zero_apply, Homotopy.add_hom, Homotopy.compLeft_hom, add_zero,
  Homotopy.nullHomotopy'_hom, ComplexShape.down_Rel, hσ'_eq_zero hqn (c_mk (n + 1) n rfl),
  dite_eq_ite, ite_self, comp_zero, zero_add, homotopyPToId]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
q n : ℕ
hqn : n < q
⊢ (homotopyPToId X (q + 1)).hom n (n + 1) = (homotopyPToId X q).hom n (n + 1)
state_after: no goals
Theorem: Nat.mul_dvd_mul_iff_left
File: Mathlib/Data/Nat/Defs.lean

tactic: rw [Nat.mul_assoc, Nat.mul_right_inj $ ne_of_gt ha]
state_before: a b c d✝ m n k : ℕ
p q : ℕ → Prop
ha : 0 < a
d : ℕ
⊢ a * c = a * b * d ↔ c = b * d
state_after: no goals
Theorem: TopologicalSpace.isSeparable_pi
File: Mathlib/Topology/Bases.lean

tactic: simpa only [← mem_univ_pi] using IsSeparable.univ_pi h
state_before: α✝ : Type u
β : Type u_1
t : TopologicalSpace α✝
B : Set (Set α✝)
s✝ : Set α✝
ι : Type u_2
inst✝¹ : Countable ι
α : ι → Type u_3
s : (i : ι) → Set (α i)
inst✝ : (i : ι) → TopologicalSpace (α i)
h : ∀ (i : ι), IsSeparable (s i)
⊢ IsSeparable {f | ∀ (i : ι), f i ∈ s i}
state_after: no goals
Theorem: Matroid.eq_emptyOn
File: Mathlib/Data/Matroid/Constructions.lean

tactic: rw [← ground_eq_empty_iff]
state_before: α : Type u_1
M✝ : Matroid α
E B I X R J : Set α
inst✝ : IsEmpty α
M : Matroid α
⊢ M = emptyOn α
state_after: α : Type u_1
M✝ : Matroid α
E B I X R J : Set α
inst✝ : IsEmpty α
M : Matroid α
⊢ M.E = ∅

tactic: exact M.E.eq_empty_of_isEmpty
state_before: α : Type u_1
M✝ : Matroid α
E B I X R J : Set α
inst✝ : IsEmpty α
M : Matroid α
⊢ M.E = ∅
state_after: no goals
Theorem: Basis.opNorm_le
File: Mathlib/Analysis/NormedSpace/FiniteDimension.lean

tactic: simpa using NNReal.coe_le_coe.mpr (v.opNNNorm_le ⟨M, hM⟩ hu)
state_before: 𝕜 : Type u
inst✝¹¹ : NontriviallyNormedField 𝕜
E : Type v
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
F : Type w
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace 𝕜 F
F' : Type x
inst✝⁶ : AddCommGroup F'
inst✝⁵ : Module 𝕜 F'
inst✝⁴ : TopologicalSpace F'
inst✝³ : TopologicalAddGroup F'
inst✝² : ContinuousSMul 𝕜 F'
inst✝¹ : CompleteSpace 𝕜
ι : Type u_1
inst✝ : Fintype ι
v : Basis ι 𝕜 E
u : E →L[𝕜] F
M : ℝ
hM : 0 ≤ M
hu : ∀ (i : ι), ‖u (v i)‖ ≤ M
⊢ ‖u‖ ≤ Fintype.card ι • ‖↑v.equivFunL‖ * M
state_after: no goals
Theorem: toUnits_val_apply
File: Mathlib/Algebra/Group/Units/Equiv.lean

tactic: simp_rw [MulEquiv.apply_eq_iff_symm_apply, toUnits_symm_apply]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
A : Type u_4
B : Type u_5
M : Type u_6
N : Type u_7
P : Type u_8
Q : Type u_9
G✝ : Type u_10
H : Type u_11
G : Type u_12
inst✝ : Group G
x : Gˣ
⊢ toUnits ↑x = x
state_after: no goals
Theorem: isClosed_iff_coe_preimage_of_iSup_eq_top
File: Mathlib/Topology/LocalAtTarget.lean

tactic: simpa using isOpen_iff_coe_preimage_of_iSup_eq_top hU sᶜ
state_before: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
f : α → β
s✝ : Set β
ι : Type u_3
U : ι → Opens β
hU : iSup U = ⊤
s : Set β
⊢ IsClosed s ↔ ∀ (i : ι), IsClosed (Subtype.val ⁻¹' s)
state_after: no goals
Theorem: SeparatedNhds.of_isCompact_isCompact_isClosed
File: Mathlib/Topology/Separation.lean

tactic: simp_rw [separatedNhds_iff_disjoint, hK.disjoint_nhdsSet_left, hL.disjoint_nhdsSet_right,
  disjoint_nhds_nhds_iff_not_inseparable]
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : FirstCountableTopology X
inst✝ : R1Space X
x y : X
K L : Set X
hK : IsCompact K
hL : IsCompact L
h'L : IsClosed L
hd : Disjoint K L
⊢ SeparatedNhds K L
state_after: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : FirstCountableTopology X
inst✝ : R1Space X
x y : X
K L : Set X
hK : IsCompact K
hL : IsCompact L
h'L : IsClosed L
hd : Disjoint K L
⊢ ∀ x ∈ K, ∀ x_1 ∈ L, ¬Inseparable x x_1

tactic: intro x hx y hy h
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : FirstCountableTopology X
inst✝ : R1Space X
x y : X
K L : Set X
hK : IsCompact K
hL : IsCompact L
h'L : IsClosed L
hd : Disjoint K L
⊢ ∀ x ∈ K, ∀ x_1 ∈ L, ¬Inseparable x x_1
state_after: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : FirstCountableTopology X
inst✝ : R1Space X
x✝ y✝ : X
K L : Set X
hK : IsCompact K
hL : IsCompact L
h'L : IsClosed L
hd : Disjoint K L
x : X
hx : x ∈ K
y : X
hy : y ∈ L
h : Inseparable x y
⊢ False

tactic: exact absurd ((h.mem_closed_iff h'L).2 hy) <| disjoint_left.1 hd hx
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : FirstCountableTopology X
inst✝ : R1Space X
x✝ y✝ : X
K L : Set X
hK : IsCompact K
hL : IsCompact L
h'L : IsClosed L
hd : Disjoint K L
x : X
hx : x ∈ K
y : X
hy : y ∈ L
h : Inseparable x y
⊢ False
state_after: no goals
Theorem: CategoryTheory.prodComparison_iso
File: Mathlib/CategoryTheory/Closed/Ideal.lean

tactic: rw [← (bijection i _ _ _).injective.eq_iff, bijection_natural, ← bijection_symm_apply_id,
  Equiv.apply_symm_apply, id_comp]
state_before: C : Type u₁
D : Type u₂
inst✝⁶ : Category.{v₁, u₁} C
inst✝⁵ : Category.{v₁, u₂} D
i : D ⥤ C
inst✝⁴ : HasFiniteProducts C
inst✝³ : Reflective i
inst✝² : CartesianClosed C
inst✝¹ : HasFiniteProducts D
inst✝ : ExponentialIdeal i
A B : C
⊢ prodComparison (reflector i) A B ≫ (bijection i A B ((reflector i).obj (A ⨯ B))) (𝟙 ((reflector i).obj (A ⨯ B))) =
    𝟙 ((reflector i).obj (A ⨯ B))
state_after: no goals

tactic: rw [← bijection_natural, id_comp, ← bijection_symm_apply_id, Equiv.apply_symm_apply]
state_before: C : Type u₁
D : Type u₂
inst✝⁶ : Category.{v₁, u₁} C
inst✝⁵ : Category.{v₁, u₂} D
i : D ⥤ C
inst✝⁴ : HasFiniteProducts C
inst✝³ : Reflective i
inst✝² : CartesianClosed C
inst✝¹ : HasFiniteProducts D
inst✝ : ExponentialIdeal i
A B : C
⊢ (bijection i A B ((reflector i).obj (A ⨯ B))) (𝟙 ((reflector i).obj (A ⨯ B))) ≫ prodComparison (reflector i) A B =
    𝟙 ((reflector i).obj A ⨯ (reflector i).obj B)
state_after: no goals
Theorem: TensorProduct.smul_tmul_smul
File: Mathlib/LinearAlgebra/TensorProduct/Basic.lean

tactic: simp_rw [smul_tmul, tmul_smul, mul_smul]
state_before: R : Type u_1
inst✝¹⁸ : CommSemiring R
R' : Type u_2
inst✝¹⁷ : Monoid R'
R'' : Type u_3
inst✝¹⁶ : Semiring R''
M : Type u_4
N : Type u_5
P : Type u_6
Q : Type u_7
S : Type u_8
T : Type u_9
inst✝¹⁵ : AddCommMonoid M
inst✝¹⁴ : AddCommMonoid N
inst✝¹³ : AddCommMonoid P
inst✝¹² : AddCommMonoid Q
inst✝¹¹ : AddCommMonoid S
inst✝¹⁰ : AddCommMonoid T
inst✝⁹ : Module R M
inst✝⁸ : Module R N
inst✝⁷ : Module R P
inst✝⁶ : Module R Q
inst✝⁵ : Module R S
inst✝⁴ : Module R T
inst✝³ : DistribMulAction R' M
inst✝² : Module R'' M
inst✝¹ : SMulCommClass R R' M
inst✝ : SMulCommClass R R'' M
r s : R
m : M
n : N
⊢ (r • m) ⊗ₜ[R] (s • n) = (r * s) • m ⊗ₜ[R] n
state_after: no goals
Theorem: pred_ne_self
File: Mathlib/Algebra/Ring/Basic.lean

tactic: simp [← sub_eq_add_neg, h]
state_before: R : Type u_1
α : Type u_2
inst✝¹ : NonAssocRing α
inst✝ : Nontrivial α
a : α
h : a - 1 = a
⊢ a + -1 = a + -0
state_after: no goals
Theorem: MvPolynomial.monomial_eq
File: Mathlib/Algebra/MvPolynomial/Basic.lean

tactic: simp only [X_pow_eq_monomial, ← monomial_finsupp_sum_index, Finsupp.sum_single]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
⊢ (monomial s) a = C a * s.prod fun n e => X n ^ e
state_after: no goals