1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: SimpleGraph.Connected.dist_eq_zero_iff
File: Mathlib/Combinatorics/SimpleGraph/Metric.lean

tactic: simp [hconn u v]
state_before: V : Type u_1
G : SimpleGraph V
hconn : G.Connected
u v : V
⊢ G.dist u v = 0 ↔ u = v
state_after: no goals
Theorem: PrimeSpectrum.isRadical_vanishingIdeal
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

tactic: rw [← vanishingIdeal_closure, ← zeroLocus_vanishingIdeal_eq_closure,
  vanishingIdeal_zeroLocus_eq_radical]
state_before: R : Type u
S : Type v
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
s : Set (PrimeSpectrum R)
⊢ (vanishingIdeal s).IsRadical
state_after: R : Type u
S : Type v
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
s : Set (PrimeSpectrum R)
⊢ (vanishingIdeal s).radical.IsRadical

tactic: apply Ideal.radical_isRadical
state_before: R : Type u
S : Type v
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
s : Set (PrimeSpectrum R)
⊢ (vanishingIdeal s).radical.IsRadical
state_after: no goals
Theorem: LieModule.mem_ker
File: Mathlib/Algebra/Lie/Abelian.lean

tactic: simp only [LieModule.ker, LieHom.mem_ker, LinearMap.ext_iff, LinearMap.zero_apply,
  toEnd_apply_apply]
state_before: R : Type u
L : Type v
M : Type w
N : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
x : L
⊢ x ∈ LieModule.ker R L M ↔ ∀ (m : M), ⁅x, m⁆ = 0
state_after: no goals
Theorem: Nat.zero_eq_mul
File: Mathlib/Data/Nat/Defs.lean

tactic: rw [eq_comm, Nat.mul_eq_zero]
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
⊢ 0 = m * n ↔ m = 0 ∨ n = 0
state_after: no goals
Theorem: List.aemeasurable_prod
File: Mathlib/MeasureTheory/Group/Arithmetic.lean

tactic: simpa only [← Pi.list_prod_apply] using l.aemeasurable_prod' hl
state_before: α✝ : Type u_1
M : Type u_2
α : Type u_3
inst✝² : Monoid M
inst✝¹ : MeasurableSpace M
inst✝ : MeasurableMul₂ M
m : MeasurableSpace α
μ : Measure α
l : List (α → M)
hl : ∀ f ∈ l, AEMeasurable f μ
⊢ AEMeasurable (fun x => (map (fun f => f x) l).prod) μ
state_after: no goals
Theorem: WeierstrassCurve.Affine.addX_eq_addX_negY_sub
File: Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean

tactic: simp_rw [slope_of_X_ne hx, addX, negY, ← neg_sub x₁, neg_sq]
state_before: R : Type u
inst✝¹ : CommRing R
W✝ : Affine R
F : Type u
inst✝ : Field F
W : Affine F
x₁ x₂ y₁ y₂ : F
hx : x₁ ≠ x₂
⊢ W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂) =
    W.addX x₁ x₂ (W.slope x₁ x₂ y₁ (W.negY x₂ y₂)) - (y₁ - W.negY x₁ y₁) * (y₂ - W.negY x₂ y₂) / (x₂ - x₁) ^ 2
state_after: R : Type u
inst✝¹ : CommRing R
W✝ : Affine R
F : Type u
inst✝ : Field F
W : Affine F
x₁ x₂ y₁ y₂ : F
hx : x₁ ≠ x₂
⊢ -(x₁ - (((y₁ - y₂) / (x₁ - x₂)) ^ 2 + W.a₁ * ((y₁ - y₂) / (x₁ - x₂)) - W.a₂)) - x₂ =
    -(x₁ -
            (((y₁ - (-y₂ - W.a₁ * x₂ - W.a₃)) / (x₁ - x₂)) ^ 2 + W.a₁ * ((y₁ - (-y₂ - W.a₁ * x₂ - W.a₃)) / (x₁ - x₂)) -
              W.a₂)) -
        x₂ -
      (y₁ - (-y₁ - W.a₁ * x₁ - W.a₃)) * (y₂ - (-y₂ - W.a₁ * x₂ - W.a₃)) / (x₁ - x₂) ^ 2

tactic: field_simp [sub_ne_zero.mpr hx]
state_before: R : Type u
inst✝¹ : CommRing R
W✝ : Affine R
F : Type u
inst✝ : Field F
W : Affine F
x₁ x₂ y₁ y₂ : F
hx : x₁ ≠ x₂
⊢ -(x₁ - (((y₁ - y₂) / (x₁ - x₂)) ^ 2 + W.a₁ * ((y₁ - y₂) / (x₁ - x₂)) - W.a₂)) - x₂ =
    -(x₁ -
            (((y₁ - (-y₂ - W.a₁ * x₂ - W.a₃)) / (x₁ - x₂)) ^ 2 + W.a₁ * ((y₁ - (-y₂ - W.a₁ * x₂ - W.a₃)) / (x₁ - x₂)) -
              W.a₂)) -
        x₂ -
      (y₁ - (-y₁ - W.a₁ * x₁ - W.a₃)) * (y₂ - (-y₂ - W.a₁ * x₂ - W.a₃)) / (x₁ - x₂) ^ 2
state_after: R : Type u
inst✝¹ : CommRing R
W✝ : Affine R
F : Type u
inst✝ : Field F
W : Affine F
x₁ x₂ y₁ y₂ : F
hx : x₁ ≠ x₂
⊢ ((y₁ - y₂) ^ 2 * (x₁ - x₂) + W.a₁ * (y₁ - y₂) * (x₁ - x₂) ^ 2 - (x₁ - x₂) ^ 2 * (x₁ - x₂) * W.a₂ -
          x₁ * ((x₁ - x₂) ^ 2 * (x₁ - x₂)) -
        (x₁ - x₂) ^ 2 * (x₁ - x₂) * x₂) *
      ((x₁ - x₂) ^ 2 * (x₁ - x₂) * (x₁ - x₂) ^ 2) =
    (((y₁ - (-y₂ - W.a₁ * x₂ - W.a₃)) ^ 2 * (x₁ - x₂) + W.a₁ * (y₁ - (-y₂ - W.a₁ * x₂ - W.a₃)) * (x₁ - x₂) ^ 2 -
                (x₁ - x₂) ^ 2 * (x₁ - x₂) * W.a₂ -
              x₁ * ((x₁ - x₂) ^ 2 * (x₁ - x₂)) -
            (x₁ - x₂) ^ 2 * (x₁ - x₂) * x₂) *
          (x₁ - x₂) ^ 2 -
        (x₁ - x₂) ^ 2 * (x₁ - x₂) * ((y₁ - (-y₁ - W.a₁ * x₁ - W.a₃)) * (y₂ - (-y₂ - W.a₁ * x₂ - W.a₃)))) *
      ((x₁ - x₂) ^ 2 * (x₁ - x₂))

tactic: ring1
state_before: R : Type u
inst✝¹ : CommRing R
W✝ : Affine R
F : Type u
inst✝ : Field F
W : Affine F
x₁ x₂ y₁ y₂ : F
hx : x₁ ≠ x₂
⊢ ((y₁ - y₂) ^ 2 * (x₁ - x₂) + W.a₁ * (y₁ - y₂) * (x₁ - x₂) ^ 2 - (x₁ - x₂) ^ 2 * (x₁ - x₂) * W.a₂ -
          x₁ * ((x₁ - x₂) ^ 2 * (x₁ - x₂)) -
        (x₁ - x₂) ^ 2 * (x₁ - x₂) * x₂) *
      ((x₁ - x₂) ^ 2 * (x₁ - x₂) * (x₁ - x₂) ^ 2) =
    (((y₁ - (-y₂ - W.a₁ * x₂ - W.a₃)) ^ 2 * (x₁ - x₂) + W.a₁ * (y₁ - (-y₂ - W.a₁ * x₂ - W.a₃)) * (x₁ - x₂) ^ 2 -
                (x₁ - x₂) ^ 2 * (x₁ - x₂) * W.a₂ -
              x₁ * ((x₁ - x₂) ^ 2 * (x₁ - x₂)) -
            (x₁ - x₂) ^ 2 * (x₁ - x₂) * x₂) *
          (x₁ - x₂) ^ 2 -
        (x₁ - x₂) ^ 2 * (x₁ - x₂) * ((y₁ - (-y₁ - W.a₁ * x₁ - W.a₃)) * (y₂ - (-y₂ - W.a₁ * x₂ - W.a₃)))) *
      ((x₁ - x₂) ^ 2 * (x₁ - x₂))
state_after: no goals
Theorem: PMF.toOuterMeasure_bind_apply
File: Mathlib/Probability/ProbabilityMassFunction/Monad.lean

tactic: simp [toOuterMeasure_apply, Set.indicator_apply]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
f : α → PMF β
g : β → PMF γ
s : Set β
⊢ (p.bind f).toOuterMeasure s = ∑' (b : β), if b ∈ s then ∑' (a : α), p a * (f a) b else 0
state_after: no goals

tactic: split_ifs <;> simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
f : α → PMF β
g : β → PMF γ
s : Set β
b : β
⊢ (if b ∈ s then ∑' (a : α), p a * (f a) b else 0) = ∑' (a : α), p a * if b ∈ s then (f a) b else 0
state_after: no goals

tactic: split_ifs <;> rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
f : α → PMF β
g : β → PMF γ
s : Set β
a : α
b : β
⊢ (if b ∈ s then (f a) b else 0) = if b ∈ s then (f a) b else 0
state_after: no goals

tactic: simp only [toOuterMeasure_apply, Set.indicator_apply]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
f : α → PMF β
g : β → PMF γ
s : Set β
a : α
⊢ (p a * ∑' (b : β), if b ∈ s then (f a) b else 0) = p a * (f a).toOuterMeasure s
state_after: no goals
Theorem: irrational_div_int_iff
File: Mathlib/Data/Real/Irrational.lean

tactic: rw [← cast_intCast, irrational_div_rat_iff, Int.cast_ne_zero]
state_before: q : ℚ
m : ℤ
n : ℕ
x : ℝ
⊢ Irrational (x / ↑m) ↔ m ≠ 0 ∧ Irrational x
state_after: no goals
Theorem: Set.preimage_mul_const_Ioo
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp [← Ioi_inter_Iio, h]
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a b c : α
h : 0 < c
⊢ (fun x => x * c) ⁻¹' Ioo a b = Ioo (a / c) (b / c)
state_after: no goals
Theorem: Polynomial.isRoot_cyclotomic_iff
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Roots.lean

tactic: have hf : Function.Injective _ := IsFractionRing.injective R (FractionRing R)
state_before: R : Type u_1
inst✝² : CommRing R
n : ℕ
inst✝¹ : IsDomain R
inst✝ : NeZero ↑n
μ : R
⊢ (cyclotomic n R).IsRoot μ ↔ IsPrimitiveRoot μ n
state_after: R : Type u_1
inst✝² : CommRing R
n : ℕ
inst✝¹ : IsDomain R
inst✝ : NeZero ↑n
μ : R
hf : Function.Injective ⇑(algebraMap R (FractionRing R))
⊢ (cyclotomic n R).IsRoot μ ↔ IsPrimitiveRoot μ n

tactic: haveI : NeZero (n : FractionRing R) := NeZero.nat_of_injective hf
state_before: R : Type u_1
inst✝² : CommRing R
n : ℕ
inst✝¹ : IsDomain R
inst✝ : NeZero ↑n
μ : R
hf : Function.Injective ⇑(algebraMap R (FractionRing R))
⊢ (cyclotomic n R).IsRoot μ ↔ IsPrimitiveRoot μ n
state_after: R : Type u_1
inst✝² : CommRing R
n : ℕ
inst✝¹ : IsDomain R
inst✝ : NeZero ↑n
μ : R
hf : Function.Injective ⇑(algebraMap R (FractionRing R))
this : NeZero ↑n
⊢ (cyclotomic n R).IsRoot μ ↔ IsPrimitiveRoot μ n

tactic: rw [← isRoot_map_iff hf, ← IsPrimitiveRoot.map_iff_of_injective hf, map_cyclotomic, ←
  isRoot_cyclotomic_iff']
state_before: R : Type u_1
inst✝² : CommRing R
n : ℕ
inst✝¹ : IsDomain R
inst✝ : NeZero ↑n
μ : R
hf : Function.Injective ⇑(algebraMap R (FractionRing R))
this : NeZero ↑n
⊢ (cyclotomic n R).IsRoot μ ↔ IsPrimitiveRoot μ n
state_after: no goals
Theorem: Vector.mapAccumr₂_unused_input_left
File: Mathlib/Data/Vector/MapLemmas.lean

tactic: induction xs, ys using Vector.revInductionOn₂ generalizing s with
| nil => rfl
| snoc xs ys x y ih => simp [h x y s, ih]
state_before: α : Type
n : ℕ
β : Type
xs : Vector α n
ys : Vector β n
σ γ : Type
s : σ
inst✝ : Inhabited α
f : α → β → σ → σ × γ
h : ∀ (a : α) (b : β) (s : σ), f default b s = f a b s
⊢ mapAccumr₂ f xs ys s = mapAccumr (fun b s => f default b s) ys s
state_after: no goals

tactic: rfl
state_before: case nil
α : Type
n : ℕ
β : Type
xs : Vector α n
ys : Vector β n
σ γ : Type
inst✝ : Inhabited α
f : α → β → σ → σ × γ
h : ∀ (a : α) (b : β) (s : σ), f default b s = f a b s
s : σ
⊢ mapAccumr₂ f nil nil s = mapAccumr (fun b s => f default b s) nil s
state_after: no goals

tactic: simp [h x y s, ih]
state_before: case snoc
α : Type
n : ℕ
β : Type
xs✝ : Vector α n
ys✝ : Vector β n
σ γ : Type
inst✝ : Inhabited α
f : α → β → σ → σ × γ
h : ∀ (a : α) (b : β) (s : σ), f default b s = f a b s
n✝ : ℕ
xs : Vector α n✝
ys : Vector β n✝
x : α
y : β
ih : ∀ {s : σ}, mapAccumr₂ f xs ys s = mapAccumr (fun b s => f default b s) ys s
s : σ
⊢ mapAccumr₂ f (xs.snoc x) (ys.snoc y) s = mapAccumr (fun b s => f default b s) (ys.snoc y) s
state_after: no goals
Theorem: CategoryTheory.Functor.map_injective_iff
File: Mathlib/CategoryTheory/Functor/FullyFaithful.lean

tactic: rw [h]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
X✝ Y✝ : C
F : C ⥤ D
inst✝ : F.Faithful
X Y : C
f g : X ⟶ Y
h : f = g
⊢ F.map f = F.map g
state_after: no goals
Theorem: UFModel.Models.rank_eq
File: Mathlib/Data/UnionFind.lean

tactic: rw [H.size_eq]
state_before: α : Type u_1
arr : Array (UFNode α)
n : ℕ
m : UFModel n
H : Models arr m
i : ℕ
h : i < arr.size
⊢ i < n
state_after: α : Type u_1
arr : Array (UFNode α)
n : ℕ
m : UFModel n
H : Models arr m
i : ℕ
h : i < arr.size
⊢ i < arr.size

tactic: exact h
state_before: α : Type u_1
arr : Array (UFNode α)
n : ℕ
m : UFModel n
H : Models arr m
i : ℕ
h : i < arr.size
⊢ i < arr.size
state_after: no goals
Theorem: schnirelmannDensity_eq_one_iff_of_zero_mem
File: Mathlib/Combinatorics/Schnirelmann.lean

tactic: rw [schnirelmannDensity_eq_one_iff]
state_before: A : Set ℕ
inst✝ : DecidablePred fun x => x ∈ A
hA : 0 ∈ A
⊢ schnirelmannDensity A = 1 ↔ A = Set.univ
state_after: A : Set ℕ
inst✝ : DecidablePred fun x => x ∈ A
hA : 0 ∈ A
⊢ {0}ᶜ ⊆ A ↔ A = Set.univ

tactic: constructor
state_before: A : Set ℕ
inst✝ : DecidablePred fun x => x ∈ A
hA : 0 ∈ A
⊢ {0}ᶜ ⊆ A ↔ A = Set.univ
state_after: case mp
A : Set ℕ
inst✝ : DecidablePred fun x => x ∈ A
hA : 0 ∈ A
⊢ {0}ᶜ ⊆ A → A = Set.univ

case mpr
A : Set ℕ
inst✝ : DecidablePred fun x => x ∈ A
hA : 0 ∈ A
⊢ A = Set.univ → {0}ᶜ ⊆ A

tactic: refine fun h => Set.eq_univ_of_forall fun x => ?_
state_before: case mp
A : Set ℕ
inst✝ : DecidablePred fun x => x ∈ A
hA : 0 ∈ A
⊢ {0}ᶜ ⊆ A → A = Set.univ
state_after: case mp
A : Set ℕ
inst✝ : DecidablePred fun x => x ∈ A
hA : 0 ∈ A
h : {0}ᶜ ⊆ A
x : ℕ
⊢ x ∈ A

tactic: rcases eq_or_ne x 0 with rfl | hx
state_before: case mp
A : Set ℕ
inst✝ : DecidablePred fun x => x ∈ A
hA : 0 ∈ A
h : {0}ᶜ ⊆ A
x : ℕ
⊢ x ∈ A
state_after: case mp.inl
A : Set ℕ
inst✝ : DecidablePred fun x => x ∈ A
hA : 0 ∈ A
h : {0}ᶜ ⊆ A
⊢ 0 ∈ A

case mp.inr
A : Set ℕ
inst✝ : DecidablePred fun x => x ∈ A
hA : 0 ∈ A
h : {0}ᶜ ⊆ A
x : ℕ
hx : x ≠ 0
⊢ x ∈ A

tactic: exact hA
state_before: case mp.inl
A : Set ℕ
inst✝ : DecidablePred fun x => x ∈ A
hA : 0 ∈ A
h : {0}ᶜ ⊆ A
⊢ 0 ∈ A
state_after: no goals

tactic: exact h hx
state_before: case mp.inr
A : Set ℕ
inst✝ : DecidablePred fun x => x ∈ A
hA : 0 ∈ A
h : {0}ᶜ ⊆ A
x : ℕ
hx : x ≠ 0
⊢ x ∈ A
state_after: no goals

tactic: rintro rfl
state_before: case mpr
A : Set ℕ
inst✝ : DecidablePred fun x => x ∈ A
hA : 0 ∈ A
⊢ A = Set.univ → {0}ᶜ ⊆ A
state_after: case mpr
inst✝ : DecidablePred fun x => x ∈ Set.univ
hA : 0 ∈ Set.univ
⊢ {0}ᶜ ⊆ Set.univ

tactic: exact Set.subset_univ {0}ᶜ
state_before: case mpr
inst✝ : DecidablePred fun x => x ∈ Set.univ
hA : 0 ∈ Set.univ
⊢ {0}ᶜ ⊆ Set.univ
state_after: no goals
Theorem: Ideal.adic_module_basis
File: Mathlib/Topology/Algebra/Nonarchimedean/AdicTopology.lean

tactic: simp
state_before: R : Type u_1
inst✝² : CommRing R
I : Ideal R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
m : M
i : ℕ
⊢ ↑(I ^ i • ⊤) = ↑((fun i => toAddSubgroup (I ^ i • ⊤)) i)
state_after: no goals

tactic: replace a_in : a ∈ I ^ i := by simpa [(I ^ i).mul_top] using a_in
state_before: R : Type u_1
inst✝² : CommRing R
I : Ideal R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
m : M
i : ℕ
a : R
a_in : a ∈ ↑(I ^ i • ⊤)
⊢ a ∈ (fun x => x • m) ⁻¹' ↑(I ^ i • ⊤)
state_after: R : Type u_1
inst✝² : CommRing R
I : Ideal R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
m : M
i : ℕ
a : R
a_in : a ∈ I ^ i
⊢ a ∈ (fun x => x • m) ⁻¹' ↑(I ^ i • ⊤)

tactic: exact smul_mem_smul a_in mem_top
state_before: R : Type u_1
inst✝² : CommRing R
I : Ideal R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
m : M
i : ℕ
a : R
a_in : a ∈ I ^ i
⊢ a ∈ (fun x => x • m) ⁻¹' ↑(I ^ i • ⊤)
state_after: no goals

tactic: simpa [(I ^ i).mul_top] using a_in
state_before: R : Type u_1
inst✝² : CommRing R
I : Ideal R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
m : M
i : ℕ
a : R
a_in : a ∈ ↑(I ^ i • ⊤)
⊢ a ∈ I ^ i
state_after: no goals
Theorem: Nat.coe_int_ofDigits
File: Mathlib/Data/Nat/Digits.lean

tactic: induction' L with d L _
state_before: n b : ℕ
L : List ℕ
⊢ ↑(ofDigits b L) = ofDigits (↑b) L
state_after: case nil
n b : ℕ
⊢ ↑(ofDigits b []) = ofDigits ↑b []

case cons
n b d : ℕ
L : List ℕ
tail_ih✝ : ↑(ofDigits b L) = ofDigits (↑b) L
⊢ ↑(ofDigits b (d :: L)) = ofDigits (↑b) (d :: L)

tactic: rfl
state_before: case nil
n b : ℕ
⊢ ↑(ofDigits b []) = ofDigits ↑b []
state_after: no goals

tactic: dsimp [ofDigits]
state_before: case cons
n b d : ℕ
L : List ℕ
tail_ih✝ : ↑(ofDigits b L) = ofDigits (↑b) L
⊢ ↑(ofDigits b (d :: L)) = ofDigits (↑b) (d :: L)
state_after: case cons
n b d : ℕ
L : List ℕ
tail_ih✝ : ↑(ofDigits b L) = ofDigits (↑b) L
⊢ ↑(d + b * ofDigits b L) = ↑d + ↑b * ofDigits (↑b) L

tactic: push_cast
state_before: case cons
n b d : ℕ
L : List ℕ
tail_ih✝ : ↑(ofDigits b L) = ofDigits (↑b) L
⊢ ↑(d + b * ofDigits b L) = ↑d + ↑b * ofDigits (↑b) L
state_after: case cons
n b d : ℕ
L : List ℕ
tail_ih✝ : ↑(ofDigits b L) = ofDigits (↑b) L
⊢ ↑d + ↑b * ofDigits (↑b) L = ↑d + ↑b * ofDigits (↑b) L

tactic: simp only
state_before: case cons
n b d : ℕ
L : List ℕ
tail_ih✝ : ↑(ofDigits b L) = ofDigits (↑b) L
⊢ ↑d + ↑b * ofDigits (↑b) L = ↑d + ↑b * ofDigits (↑b) L
state_after: no goals
Theorem: Multiplicative.isNormalSubgroup_iff
File: Mathlib/Deprecated/Subgroup.lean

tactic: rintro ⟨h₁, h₂⟩
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝ : AddGroup A
s : Set A
⊢ IsNormalSubgroup s → IsNormalAddSubgroup s
state_after: case mk
G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝ : AddGroup A
s : Set A
h₁ : IsSubgroup s
h₂ : ∀ n ∈ s, ∀ (g : Multiplicative A), g * n * g⁻¹ ∈ s
⊢ IsNormalAddSubgroup s

tactic: exact @IsNormalAddSubgroup.mk A _ _ (Multiplicative.isSubgroup_iff.1 h₁) @h₂
state_before: case mk
G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝ : AddGroup A
s : Set A
h₁ : IsSubgroup s
h₂ : ∀ n ∈ s, ∀ (g : Multiplicative A), g * n * g⁻¹ ∈ s
⊢ IsNormalAddSubgroup s
state_after: no goals
Theorem: MeasureTheory.IsStoppingTime.measurableSet_stopping_time_le
File: Mathlib/Probability/Process/Stopping.lean

tactic: exact measurableSet_le_stopping_time hτ hπ
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝⁵ : LinearOrder ι
f : Filtration ι m
τ π : Ω → ι
inst✝⁴ : TopologicalSpace ι
inst✝³ : SecondCountableTopology ι
inst✝² : OrderTopology ι
inst✝¹ : MeasurableSpace ι
inst✝ : BorelSpace ι
hτ : IsStoppingTime f τ
hπ : IsStoppingTime f π
⊢ MeasurableSet {ω | τ ω ≤ π ω}
state_after: no goals

tactic: rw [measurableSet_min_iff hτ hπ] at this
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝⁵ : LinearOrder ι
f : Filtration ι m
τ π : Ω → ι
inst✝⁴ : TopologicalSpace ι
inst✝³ : SecondCountableTopology ι
inst✝² : OrderTopology ι
inst✝¹ : MeasurableSpace ι
inst✝ : BorelSpace ι
hτ : IsStoppingTime f τ
hπ : IsStoppingTime f π
this : MeasurableSet {ω | τ ω ≤ π ω}
⊢ MeasurableSet {ω | τ ω ≤ π ω}
state_after: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝⁵ : LinearOrder ι
f : Filtration ι m
τ π : Ω → ι
inst✝⁴ : TopologicalSpace ι
inst✝³ : SecondCountableTopology ι
inst✝² : OrderTopology ι
inst✝¹ : MeasurableSpace ι
inst✝ : BorelSpace ι
hτ : IsStoppingTime f τ
hπ : IsStoppingTime f π
this : MeasurableSet {ω | τ ω ≤ π ω} ∧ MeasurableSet {ω | τ ω ≤ π ω}
⊢ MeasurableSet {ω | τ ω ≤ π ω}

tactic: exact this.2
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝⁵ : LinearOrder ι
f : Filtration ι m
τ π : Ω → ι
inst✝⁴ : TopologicalSpace ι
inst✝³ : SecondCountableTopology ι
inst✝² : OrderTopology ι
inst✝¹ : MeasurableSpace ι
inst✝ : BorelSpace ι
hτ : IsStoppingTime f τ
hπ : IsStoppingTime f π
this : MeasurableSet {ω | τ ω ≤ π ω} ∧ MeasurableSet {ω | τ ω ≤ π ω}
⊢ MeasurableSet {ω | τ ω ≤ π ω}
state_after: no goals
Theorem: Real.exp_mul
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rw [rpow_def_of_pos (exp_pos _), log_exp]
state_before: x✝ y✝ z x y : ℝ
⊢ rexp (x * y) = rexp x ^ y
state_after: no goals
Theorem: skewAdjointMatricesLieSubalgebraEquiv_apply
File: Mathlib/Algebra/Lie/SkewAdjoint.lean

tactic: simp [skewAdjointMatricesLieSubalgebraEquiv]
state_before: R : Type u
n : Type w
inst✝² : CommRing R
inst✝¹ : DecidableEq n
inst✝ : Fintype n
J P : Matrix n n R
h : Invertible P
A : ↥(skewAdjointMatricesLieSubalgebra J)
⊢ ↑((skewAdjointMatricesLieSubalgebraEquiv J P h) A) = P⁻¹ * ↑A * P
state_after: no goals
Theorem: Finset.range_add_one'
File: Mathlib/Data/Finset/Image.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
n i j : ℕ
⊢ (fun i => i + 1) i = (fun i => i + 1) j → i = j
state_after: no goals

tactic: ext (⟨⟩ | ⟨n⟩) <;> simp [Nat.zero_lt_succ n]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
n : ℕ
⊢ range (n + 1) = insert 0 (map { toFun := fun i => i + 1, inj' := ⋯ } (range n))
state_after: no goals
Theorem: AlgebraicTopology.DoldKan.QInfty_f_comp_PInfty_f
File: Mathlib/AlgebraicTopology/DoldKan/PInfty.lean

tactic: dsimp only [QInfty]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
n : ℕ
⊢ QInfty.f n ≫ PInfty.f n = 0
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
n : ℕ
⊢ (𝟙 K[X] - PInfty).f n ≫ PInfty.f n = 0

tactic: simp only [HomologicalComplex.sub_f_apply, HomologicalComplex.id_f, sub_comp, id_comp,
  PInfty_f_idem, sub_self]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
n : ℕ
⊢ (𝟙 K[X] - PInfty).f n ≫ PInfty.f n = 0
state_after: no goals
Theorem: Real.log_nonpos_iff'
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: rcases hx.eq_or_lt with (rfl | hx)
state_before: x y : ℝ
hx : 0 ≤ x
⊢ log x ≤ 0 ↔ x ≤ 1
state_after: case inl
y : ℝ
hx : 0 ≤ 0
⊢ log 0 ≤ 0 ↔ 0 ≤ 1

case inr
x y : ℝ
hx✝ : 0 ≤ x
hx : 0 < x
⊢ log x ≤ 0 ↔ x ≤ 1

tactic: exact log_nonpos_iff hx
state_before: case inr
x y : ℝ
hx✝ : 0 ≤ x
hx : 0 < x
⊢ log x ≤ 0 ↔ x ≤ 1
state_after: no goals

tactic: simp [le_refl, zero_le_one]
state_before: case inl
y : ℝ
hx : 0 ≤ 0
⊢ log 0 ≤ 0 ↔ 0 ≤ 1
state_after: no goals
Theorem: Finset.shatters_iff
File: Mathlib/Combinatorics/SetFamily/Shatter.lean

tactic: ext t
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s t : Finset α
a : α
n : ℕ
h : 𝒜.Shatters s
⊢ image (fun t => s ∩ t) 𝒜 = s.powerset
state_after: case a
α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s t✝ : Finset α
a : α
n : ℕ
h : 𝒜.Shatters s
t : Finset α
⊢ t ∈ image (fun t => s ∩ t) 𝒜 ↔ t ∈ s.powerset

tactic: rw [mem_image, mem_powerset, h.subset_iff]
state_before: case a
α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s t✝ : Finset α
a : α
n : ℕ
h : 𝒜.Shatters s
t : Finset α
⊢ t ∈ image (fun t => s ∩ t) 𝒜 ↔ t ∈ s.powerset
state_after: no goals

tactic: rwa [← mem_powerset, ← h, mem_image] at ht
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s t✝ : Finset α
a : α
n : ℕ
h : image (fun t => s ∩ t) 𝒜 = s.powerset
t : Finset α
ht : t ⊆ s
⊢ ∃ u ∈ 𝒜, s ∩ u = t
state_after: no goals
Theorem: Set.neg_mem_center
File: Mathlib/Algebra/Ring/Center.lean

tactic: rw [← neg_mul_comm, ← ha.comm, neg_mul_comm]
state_before: M : Type u_1
inst✝ : NonUnitalNonAssocRing M
a : M
ha : a ∈ center M
x✝ : M
⊢ -a * x✝ = x✝ * -a
state_after: no goals

tactic: rw [neg_mul, ha.left_assoc, neg_mul, neg_mul]
state_before: M : Type u_1
inst✝ : NonUnitalNonAssocRing M
a : M
ha : a ∈ center M
x✝¹ x✝ : M
⊢ -a * (x✝¹ * x✝) = -a * x✝¹ * x✝
state_after: no goals

tactic: rw [← neg_mul_comm, ha.mid_assoc, neg_mul_comm, neg_mul]
state_before: M : Type u_1
inst✝ : NonUnitalNonAssocRing M
a : M
ha : a ∈ center M
x✝¹ x✝ : M
⊢ x✝¹ * -a * x✝ = x✝¹ * (-a * x✝)
state_after: no goals

tactic: rw [mul_neg, ha.right_assoc, mul_neg, mul_neg]
state_before: M : Type u_1
inst✝ : NonUnitalNonAssocRing M
a : M
ha : a ∈ center M
x✝¹ x✝ : M
⊢ x✝¹ * x✝ * -a = x✝¹ * (x✝ * -a)
state_after: no goals
Theorem: Vector.eq_cons_iff
File: Mathlib/Data/Vector/Basic.lean

tactic: rw [h.1, h.2]
state_before: n : ℕ
α : Type u_1
a : α
v : Vector α n.succ
v' : Vector α n
h : v.head = a ∧ v.tail = v'
⊢ v.head ::ᵥ v.tail = a ::ᵥ v'
state_after: no goals
Theorem: ProbabilityTheory.lintegral_condKernel_mem
File: Mathlib/Probability/Kernel/Disintegration/Integral.lean

tactic: conv_rhs => rw [← kernel.compProd_fst_condKernel κ]
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : CountableOrCountablyGenerated α β
κ : ↥(kernel α (β × Ω))
inst✝ : IsFiniteKernel κ
f : β × Ω → ℝ≥0∞
a : α
s : Set (β × Ω)
hs : MeasurableSet s
⊢ ∫⁻ (x : β), ((kernel.condKernel κ) (a, x)) {y | (x, y) ∈ s} ∂(kernel.fst κ) a = (κ a) s
state_after: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : CountableOrCountablyGenerated α β
κ : ↥(kernel α (β × Ω))
inst✝ : IsFiniteKernel κ
f : β × Ω → ℝ≥0∞
a : α
s : Set (β × Ω)
hs : MeasurableSet s
⊢ ∫⁻ (x : β), ((kernel.condKernel κ) (a, x)) {y | (x, y) ∈ s} ∂(kernel.fst κ) a =
    ((kernel.fst κ ⊗ₖ kernel.condKernel κ) a) s

tactic: simp_rw [kernel.compProd_apply _ _ _ hs]
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : CountableOrCountablyGenerated α β
κ : ↥(kernel α (β × Ω))
inst✝ : IsFiniteKernel κ
f : β × Ω → ℝ≥0∞
a : α
s : Set (β × Ω)
hs : MeasurableSet s
⊢ ∫⁻ (x : β), ((kernel.condKernel κ) (a, x)) {y | (x, y) ∈ s} ∂(kernel.fst κ) a =
    ((kernel.fst κ ⊗ₖ kernel.condKernel κ) a) s
state_after: no goals
Theorem: div_le_one_of_le
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rwa [one_mul]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
h : a ≤ b
hb : 0 ≤ b
⊢ a ≤ 1 * b
state_after: no goals
Theorem: expNegInvGlue.zero_of_nonpos
File: Mathlib/Analysis/SpecialFunctions/SmoothTransition.lean

tactic: simp [expNegInvGlue, hx]
state_before: x : ℝ
hx : x ≤ 0
⊢ expNegInvGlue x = 0
state_after: no goals
Theorem: Complex.reCLM_norm
File: Mathlib/Analysis/Complex/OperatorNorm.lean

tactic: simp
state_before: ⊢ 1 = ‖reCLM 1‖
state_after: no goals

tactic: simp
state_before: ⊢ ‖1‖ ≤ 1
state_after: no goals