1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: MeasurableEmbedding.comap_add
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: ext s hs
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 α
m1 : MeasurableSpace β
f : α → β
μ✝ ν✝ : Measure α
hf : MeasurableEmbedding f
μ ν : Measure β
⊢ Measure.comap f (μ + ν) = Measure.comap f μ + Measure.comap f ν
state_after: case h
α : 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 α
m1 : MeasurableSpace β
f : α → β
μ✝ ν✝ : Measure α
hf : MeasurableEmbedding f
μ ν : Measure β
s : Set α
hs : MeasurableSet s
⊢ (Measure.comap f (μ + ν)) s = (Measure.comap f μ + Measure.comap f ν) s

tactic: simp only [← comapₗ_eq_comap _ hf.injective (fun _ ↦ hf.measurableSet_image.mpr) _ hs,
  _root_.map_add, add_apply]
state_before: case h
α : 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 α
m1 : MeasurableSpace β
f : α → β
μ✝ ν✝ : Measure α
hf : MeasurableEmbedding f
μ ν : Measure β
s : Set α
hs : MeasurableSet s
⊢ (Measure.comap f (μ + ν)) s = (Measure.comap f μ + Measure.comap f ν) s
state_after: no goals
Theorem: Nat.digits_len_le_digits_len_succ
File: Mathlib/Data/Nat/Digits.lean

tactic: rcases Decidable.eq_or_ne n 0 with (rfl | hn)
state_before: n✝ b n : ℕ
⊢ (b.digits n).length ≤ (b.digits (n + 1)).length
state_after: case inl
n b : ℕ
⊢ (b.digits 0).length ≤ (b.digits (0 + 1)).length

case inr
n✝ b n : ℕ
hn : n ≠ 0
⊢ (b.digits n).length ≤ (b.digits (n + 1)).length

tactic: rcases le_or_lt b 1 with hb | hb
state_before: case inr
n✝ b n : ℕ
hn : n ≠ 0
⊢ (b.digits n).length ≤ (b.digits (n + 1)).length
state_after: case inr.inl
n✝ b n : ℕ
hn : n ≠ 0
hb : b ≤ 1
⊢ (b.digits n).length ≤ (b.digits (n + 1)).length

case inr.inr
n✝ b n : ℕ
hn : n ≠ 0
hb : 1 < b
⊢ (b.digits n).length ≤ (b.digits (n + 1)).length

tactic: simpa [digits_len, hb, hn] using log_mono_right (le_succ _)
state_before: case inr.inr
n✝ b n : ℕ
hn : n ≠ 0
hb : 1 < b
⊢ (b.digits n).length ≤ (b.digits (n + 1)).length
state_after: no goals

tactic: simp
state_before: case inl
n b : ℕ
⊢ (b.digits 0).length ≤ (b.digits (0 + 1)).length
state_after: no goals

tactic: interval_cases b <;> simp_arith [digits_zero_succ', hn]
state_before: case inr.inl
n✝ b n : ℕ
hn : n ≠ 0
hb : b ≤ 1
⊢ (b.digits n).length ≤ (b.digits (n + 1)).length
state_after: no goals
Theorem: Multiset.mem_join
File: Mathlib/Data/Multiset/Bind.lean

tactic: simp
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
a : α
S : Multiset (Multiset α)
⊢ a ∈ join 0 ↔ ∃ s ∈ 0, a ∈ s
state_after: no goals

tactic: simp (config := { contextual := true }) [or_and_right, exists_or]
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
a : α
S : Multiset (Multiset α)
⊢ ∀ (a_1 : Multiset α) (s : Multiset (Multiset α)),
    (a ∈ s.join ↔ ∃ s_1 ∈ s, a ∈ s_1) → (a ∈ (a_1 ::ₘ s).join ↔ ∃ s_1 ∈ a_1 ::ₘ s, a ∈ s_1)
state_after: no goals
Theorem: DFA.toNFA_evalFrom_match
File: Mathlib/Computability/NFA.lean

tactic: change List.foldl M.toNFA.stepSet {start} s = {List.foldl M.step start s}
state_before: α : Type u
σ σ' : Type v
M✝ : NFA α σ
M : DFA α σ
start : σ
s : List α
⊢ M.toNFA.evalFrom {start} s = {M.evalFrom start s}
state_after: α : Type u
σ σ' : Type v
M✝ : NFA α σ
M : DFA α σ
start : σ
s : List α
⊢ List.foldl M.toNFA.stepSet {start} s = {List.foldl M.step start s}

tactic: induction' s with a s ih generalizing start
state_before: α : Type u
σ σ' : Type v
M✝ : NFA α σ
M : DFA α σ
start : σ
s : List α
⊢ List.foldl M.toNFA.stepSet {start} s = {List.foldl M.step start s}
state_after: case nil
α : Type u
σ σ' : Type v
M✝ : NFA α σ
M : DFA α σ
start : σ
⊢ List.foldl M.toNFA.stepSet {start} [] = {List.foldl M.step start []}

case cons
α : Type u
σ σ' : Type v
M✝ : NFA α σ
M : DFA α σ
a : α
s : List α
ih : ∀ (start : σ), List.foldl M.toNFA.stepSet {start} s = {List.foldl M.step start s}
start : σ
⊢ List.foldl M.toNFA.stepSet {start} (a :: s) = {List.foldl M.step start (a :: s)}

tactic: tauto
state_before: case nil
α : Type u
σ σ' : Type v
M✝ : NFA α σ
M : DFA α σ
start : σ
⊢ List.foldl M.toNFA.stepSet {start} [] = {List.foldl M.step start []}
state_after: no goals

tactic: rw [List.foldl, List.foldl,
  show M.toNFA.stepSet {start} a = {M.step start a} by simp [NFA.stepSet] ]
state_before: case cons
α : Type u
σ σ' : Type v
M✝ : NFA α σ
M : DFA α σ
a : α
s : List α
ih : ∀ (start : σ), List.foldl M.toNFA.stepSet {start} s = {List.foldl M.step start s}
start : σ
⊢ List.foldl M.toNFA.stepSet {start} (a :: s) = {List.foldl M.step start (a :: s)}
state_after: case cons
α : Type u
σ σ' : Type v
M✝ : NFA α σ
M : DFA α σ
a : α
s : List α
ih : ∀ (start : σ), List.foldl M.toNFA.stepSet {start} s = {List.foldl M.step start s}
start : σ
⊢ List.foldl M.toNFA.stepSet {M.step start a} s = {List.foldl M.step (M.step start a) s}

tactic: tauto
state_before: case cons
α : Type u
σ σ' : Type v
M✝ : NFA α σ
M : DFA α σ
a : α
s : List α
ih : ∀ (start : σ), List.foldl M.toNFA.stepSet {start} s = {List.foldl M.step start s}
start : σ
⊢ List.foldl M.toNFA.stepSet {M.step start a} s = {List.foldl M.step (M.step start a) s}
state_after: no goals

tactic: simp [NFA.stepSet]
state_before: α : Type u
σ σ' : Type v
M✝ : NFA α σ
M : DFA α σ
a : α
s : List α
ih : ∀ (start : σ), List.foldl M.toNFA.stepSet {start} s = {List.foldl M.step start s}
start : σ
⊢ M.toNFA.stepSet {start} a = {M.step start a}
state_after: no goals
Theorem: eq_mul_inv_iff_mul_eq
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [h, inv_mul_cancel_right]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
h : a = b * c⁻¹
⊢ a * c = b
state_after: no goals

tactic: rw [← h, mul_inv_cancel_right]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
h : a * c = b
⊢ a = b * c⁻¹
state_after: no goals
Theorem: separatesPoints_continuous_of_t35Space
File: Mathlib/Topology/CompletelyRegular.lean

tactic: intro x y x_ne_y
state_before: X : Type u
inst✝² : TopologicalSpace X
inst✝¹ : T1Space X
inst✝ : T35Space X
⊢ SeparatesPoints Continuous
state_after: X : Type u
inst✝² : TopologicalSpace X
inst✝¹ : T1Space X
inst✝ : T35Space X
x y : X
x_ne_y : x ≠ y
⊢ ∃ f ∈ Continuous, f x ≠ f y

tactic: obtain ⟨f, f_cont, f_zero, f_one⟩ :=
  CompletelyRegularSpace.completely_regular x {y} isClosed_singleton x_ne_y
state_before: X : Type u
inst✝² : TopologicalSpace X
inst✝¹ : T1Space X
inst✝ : T35Space X
x y : X
x_ne_y : x ≠ y
⊢ ∃ f ∈ Continuous, f x ≠ f y
state_after: case intro.intro.intro
X : Type u
inst✝² : TopologicalSpace X
inst✝¹ : T1Space X
inst✝ : T35Space X
x y : X
x_ne_y : x ≠ y
f : X → ↑I
f_cont : Continuous f
f_zero : f x = 0
f_one : EqOn f 1 {y}
⊢ ∃ f ∈ Continuous, f x ≠ f y

tactic: exact ⟨fun x ↦ f x, continuous_subtype_val.comp f_cont, by aesop⟩
state_before: case intro.intro.intro
X : Type u
inst✝² : TopologicalSpace X
inst✝¹ : T1Space X
inst✝ : T35Space X
x y : X
x_ne_y : x ≠ y
f : X → ↑I
f_cont : Continuous f
f_zero : f x = 0
f_one : EqOn f 1 {y}
⊢ ∃ f ∈ Continuous, f x ≠ f y
state_after: no goals

tactic: aesop
state_before: X : Type u
inst✝² : TopologicalSpace X
inst✝¹ : T1Space X
inst✝ : T35Space X
x y : X
x_ne_y : x ≠ y
f : X → ↑I
f_cont : Continuous f
f_zero : f x = 0
f_one : EqOn f 1 {y}
⊢ (fun x => ↑(f x)) x ≠ (fun x => ↑(f x)) y
state_after: no goals
Theorem: Equiv.Perm.isCycle_of_prime_order
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

tactic: obtain ⟨n, hn⟩ := cycleType_prime_order h1
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ : Perm α
h1 : Nat.Prime (orderOf σ)
h2 : σ.support.card < 2 * orderOf σ
⊢ σ.IsCycle
state_after: case intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ : Perm α
h1 : Nat.Prime (orderOf σ)
h2 : σ.support.card < 2 * orderOf σ
n : ℕ
hn : σ.cycleType = Multiset.replicate (n + 1) (orderOf σ)
⊢ σ.IsCycle

tactic: rw [← σ.sum_cycleType, hn, Multiset.sum_replicate, nsmul_eq_mul, Nat.cast_id,
  mul_lt_mul_right (orderOf_pos σ), Nat.succ_lt_succ_iff, Nat.lt_succ_iff, Nat.le_zero] at h2
state_before: case intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ : Perm α
h1 : Nat.Prime (orderOf σ)
h2 : σ.support.card < 2 * orderOf σ
n : ℕ
hn : σ.cycleType = Multiset.replicate (n + 1) (orderOf σ)
⊢ σ.IsCycle
state_after: case intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ : Perm α
h1 : Nat.Prime (orderOf σ)
n : ℕ
h2 : n = 0
hn : σ.cycleType = Multiset.replicate (n + 1) (orderOf σ)
⊢ σ.IsCycle

tactic: rw [← card_cycleType_eq_one, hn, card_replicate, h2]
state_before: case intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ : Perm α
h1 : Nat.Prime (orderOf σ)
n : ℕ
h2 : n = 0
hn : σ.cycleType = Multiset.replicate (n + 1) (orderOf σ)
⊢ σ.IsCycle
state_after: no goals
Theorem: LieIdeal.derivedSeries_eq_derivedSeriesOfIdeal_map
File: Mathlib/Algebra/Lie/Solvable.lean

tactic: rw [derivedSeries_eq_derivedSeriesOfIdeal_comap, map_comap_incl, inf_eq_right]
state_before: R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
k : ℕ
⊢ map I.incl (derivedSeries R (↥↑I) k) = derivedSeriesOfIdeal R L k I
state_after: R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
k : ℕ
⊢ derivedSeriesOfIdeal R L k I ≤ I

tactic: apply derivedSeriesOfIdeal_le_self
state_before: R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
k : ℕ
⊢ derivedSeriesOfIdeal R L k I ≤ I
state_after: no goals
Theorem: Mathlib.Meta.Multiset.range_zero'
File: Mathlib/Tactic/NormNum/BigOperators.lean

tactic: rw [pn.out, Nat.cast_zero, Multiset.range_zero]
state_before: n : ℕ
pn : NormNum.IsNat n 0
⊢ Multiset.range n = 0
state_after: no goals
Theorem: Primrec.nat_mod
File: Mathlib/Computability/Primrec.lean

tactic: apply Nat.sub_eq_of_eq_add
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
σ : Type u_5
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable δ
inst✝ : Primcodable σ
m n : ℕ
⊢ (m, n).1 - (m, n).2 * (fun x x_1 => x / x_1) (m, n).1 (m, n).2 = m % n
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
σ : Type u_5
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable δ
inst✝ : Primcodable σ
m n : ℕ
⊢ (m, n).1 = m % n + (m, n).2 * (fun x x_1 => x / x_1) (m, n).1 (m, n).2

tactic: simp [add_comm (m % n), Nat.div_add_mod]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
σ : Type u_5
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable δ
inst✝ : Primcodable σ
m n : ℕ
⊢ (m, n).1 = m % n + (m, n).2 * (fun x x_1 => x / x_1) (m, n).1 (m, n).2
state_after: no goals
Theorem: Set.injOn_insert
File: Mathlib/Data/Set/Function.lean

tactic: rw [← union_singleton, injOn_union (disjoint_singleton_right.2 has)]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s✝ s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f✝ f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a✝ : α
b : β
f : α → β
s : Set α
a : α
has : a ∉ s
⊢ InjOn f (insert a s) ↔ InjOn f s ∧ f a ∉ f '' s
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s✝ s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f✝ f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a✝ : α
b : β
f : α → β
s : Set α
a : α
has : a ∉ s
⊢ (InjOn f s ∧ InjOn f {a} ∧ ∀ x ∈ s, ∀ y ∈ {a}, f x ≠ f y) ↔ InjOn f s ∧ f a ∉ f '' s

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s✝ s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f✝ f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a✝ : α
b : β
f : α → β
s : Set α
a : α
has : a ∉ s
⊢ (InjOn f s ∧ InjOn f {a} ∧ ∀ x ∈ s, ∀ y ∈ {a}, f x ≠ f y) ↔ InjOn f s ∧ f a ∉ f '' s
state_after: no goals
Theorem: Set.uIcc_injective_right
File: Mathlib/Order/Interval/Set/UnorderedInterval.lean

tactic: rw [ext_iff] at h
state_before: α : Type u_1
β : Type u_2
inst✝ : DistribLattice α
a✝ a₁ a₂ b✝ b₁ b₂ c✝ x a b c : α
h : (fun b => [[b, a]]) b = (fun b => [[b, a]]) c
⊢ b = c
state_after: α : Type u_1
β : Type u_2
inst✝ : DistribLattice α
a✝ a₁ a₂ b✝ b₁ b₂ c✝ x a b c : α
h : ∀ (x : α), x ∈ (fun b => [[b, a]]) b ↔ x ∈ (fun b => [[b, a]]) c
⊢ b = c

tactic: exact eq_of_mem_uIcc_of_mem_uIcc ((h _).1 left_mem_uIcc) ((h _).2 left_mem_uIcc)
state_before: α : Type u_1
β : Type u_2
inst✝ : DistribLattice α
a✝ a₁ a₂ b✝ b₁ b₂ c✝ x a b c : α
h : ∀ (x : α), x ∈ (fun b => [[b, a]]) b ↔ x ∈ (fun b => [[b, a]]) c
⊢ b = c
state_after: no goals
Theorem: CategoryTheory.ShortComplex.RightHomologyData.rightHomologyIso_hom_naturality
File: Mathlib/Algebra/Homology/ShortComplex/Homology.lean

tactic: rw [← cancel_epi h₁.homologyIso.inv, Iso.inv_hom_id_assoc,
  ← cancel_epi (leftRightHomologyComparison' S₁.leftHomologyData h₁),
  ← leftRightHomologyComparison'_naturality φ S₁.leftHomologyData h₁ S₂.leftHomologyData h₂,
  ← cancel_epi (S₁.leftHomologyData.homologyIso.hom),
  LeftHomologyData.leftHomologyIso_hom_naturality_assoc,
  leftRightHomologyComparison'_fac, leftRightHomologyComparison'_fac, assoc,
  Iso.hom_inv_id_assoc, Iso.hom_inv_id_assoc, Iso.hom_inv_id_assoc]
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ✝ : S₁ ⟶ S₂
h₁✝ : S₁.HomologyData
h₂✝ : S₂.HomologyData
inst✝¹ : S₁.HasHomology
inst✝ : S₂.HasHomology
φ : S₁ ⟶ S₂
h₁ : S₁.RightHomologyData
h₂ : S₂.RightHomologyData
⊢ h₁.homologyIso.hom ≫ rightHomologyMap' φ h₁ h₂ = homologyMap φ ≫ h₂.homologyIso.hom
state_after: no goals
Theorem: Equiv.Perm.toCycle_eq_toList
File: Mathlib/GroupTheory/Perm/Cycle/Concrete.lean

tactic: have key : (Finset.univ : Finset α).val = x ::ₘ Finset.univ.val.erase x := by simp
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x✝ : α
f : Perm α
hf : f.IsCycle
x : α
hx : f x ≠ x
⊢ f.toCycle hf = ↑(f.toList x)
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x✝ : α
f : Perm α
hf : f.IsCycle
x : α
hx : f x ≠ x
key : Finset.univ.val = x ::ₘ Finset.univ.val.erase x
⊢ f.toCycle hf = ↑(f.toList x)

tactic: rw [toCycle, key]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x✝ : α
f : Perm α
hf : f.IsCycle
x : α
hx : f x ≠ x
key : Finset.univ.val = x ::ₘ Finset.univ.val.erase x
⊢ f.toCycle hf = ↑(f.toList x)
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x✝ : α
f : Perm α
hf : f.IsCycle
x : α
hx : f x ≠ x
key : Finset.univ.val = x ::ₘ Finset.univ.val.erase x
⊢ (x ::ₘ Finset.univ.val.erase x).recOn (Quot.mk Setoid.r []) (fun x x_1 l => if f x = x then l else ↑(f.toList x)) ⋯ =
    ↑(f.toList x)

tactic: simp [hx]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x✝ : α
f : Perm α
hf : f.IsCycle
x : α
hx : f x ≠ x
key : Finset.univ.val = x ::ₘ Finset.univ.val.erase x
⊢ (x ::ₘ Finset.univ.val.erase x).recOn (Quot.mk Setoid.r []) (fun x x_1 l => if f x = x then l else ↑(f.toList x)) ⋯ =
    ↑(f.toList x)
state_after: no goals

tactic: simp
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x✝ : α
f : Perm α
hf : f.IsCycle
x : α
hx : f x ≠ x
⊢ Finset.univ.val = x ::ₘ Finset.univ.val.erase x
state_after: no goals
Theorem: Ideal.ofList_cons_smul
File: Mathlib/RingTheory/Regular/RegularSequence.lean

tactic: rw [ofList_cons, Submodule.sup_smul, Submodule.ideal_span_singleton_smul]
state_before: R✝ : Type u_1
S : Type u_2
M✝ : Type u_3
M₂ : Type u_4
M₃ : Type u_5
M₄ : Type u_6
inst✝⁴ : Semiring R✝
inst✝³ : Semiring S
R : Type u_7
inst✝² : CommSemiring R
r : R
rs : List R
M : Type u_8
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
N : Submodule R M
⊢ ofList (r :: rs) • N = r • N ⊔ ofList rs • N
state_after: no goals
Theorem: LinearEquiv.flip_flip
File: Mathlib/LinearAlgebra/PerfectPairing.lean

tactic: ext
state_before: R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : IsReflexive R M
e : N ≃ₗ[R] Dual R M
h : optParam (IsReflexive R N) ⋯
⊢ e.flip.flip = e
state_after: case h.h
R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : IsReflexive R M
e : N ≃ₗ[R] Dual R M
h : optParam (IsReflexive R N) ⋯
x✝¹ : N
x✝ : M
⊢ (e.flip.flip x✝¹) x✝ = (e x✝¹) x✝

tactic: rfl
state_before: case h.h
R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : IsReflexive R M
e : N ≃ₗ[R] Dual R M
h : optParam (IsReflexive R N) ⋯
x✝¹ : N
x✝ : M
⊢ (e.flip.flip x✝¹) x✝ = (e x✝¹) x✝
state_after: no goals
Theorem: ZFSet.toSet_inter
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: change (ZFSet.sep (fun z => z ∈ y) x).toSet = _
state_before: x y : ZFSet
⊢ (x ∩ y).toSet = x.toSet ∩ y.toSet
state_after: x y : ZFSet
⊢ (ZFSet.sep (fun z => z ∈ y) x).toSet = x.toSet ∩ y.toSet

tactic: ext
state_before: x y : ZFSet
⊢ (ZFSet.sep (fun z => z ∈ y) x).toSet = x.toSet ∩ y.toSet
state_after: case h
x y x✝ : ZFSet
⊢ x✝ ∈ (ZFSet.sep (fun z => z ∈ y) x).toSet ↔ x✝ ∈ x.toSet ∩ y.toSet

tactic: simp
state_before: case h
x y x✝ : ZFSet
⊢ x✝ ∈ (ZFSet.sep (fun z => z ∈ y) x).toSet ↔ x✝ ∈ x.toSet ∩ y.toSet
state_after: no goals
Theorem: Surreal.Multiplication.P3_neg
File: Mathlib/SetTheory/Surreal/Multiplication.lean

tactic: simp_rw [P3, quot_neg_mul]
state_before: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
⊢ P3 x₁ x₂ y₁ y₂ ↔ P3 (-x₂) (-x₁) y₁ y₂
state_after: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
⊢ ⟦x₁ * y₂⟧ + ⟦x₂ * y₁⟧ < ⟦x₁ * y₁⟧ + ⟦x₂ * y₂⟧ ↔ -⟦x₂ * y₂⟧ + -⟦x₁ * y₁⟧ < -⟦x₂ * y₁⟧ + -⟦x₁ * y₂⟧

tactic: rw [← _root_.neg_lt_neg_iff]
state_before: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
⊢ ⟦x₁ * y₂⟧ + ⟦x₂ * y₁⟧ < ⟦x₁ * y₁⟧ + ⟦x₂ * y₂⟧ ↔ -⟦x₂ * y₂⟧ + -⟦x₁ * y₁⟧ < -⟦x₂ * y₁⟧ + -⟦x₁ * y₂⟧
state_after: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
⊢ -(⟦x₁ * y₁⟧ + ⟦x₂ * y₂⟧) < -(⟦x₁ * y₂⟧ + ⟦x₂ * y₁⟧) ↔ -⟦x₂ * y₂⟧ + -⟦x₁ * y₁⟧ < -⟦x₂ * y₁⟧ + -⟦x₁ * y₂⟧

tactic: abel_nf
state_before: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
⊢ -(⟦x₁ * y₁⟧ + ⟦x₂ * y₂⟧) < -(⟦x₁ * y₂⟧ + ⟦x₂ * y₁⟧) ↔ -⟦x₂ * y₂⟧ + -⟦x₁ * y₁⟧ < -⟦x₂ * y₁⟧ + -⟦x₁ * y₂⟧
state_after: no goals
Theorem: Int.associated_iff
File: Mathlib/Algebra/GCDMonoid/Nat.lean

tactic: rw [Int.associated_iff_natAbs]
state_before: a b : ℤ
⊢ Associated a b ↔ a = b ∨ a = -b
state_after: a b : ℤ
⊢ a.natAbs = b.natAbs ↔ a = b ∨ a = -b

tactic: exact Int.natAbs_eq_natAbs_iff
state_before: a b : ℤ
⊢ a.natAbs = b.natAbs ↔ a = b ∨ a = -b
state_after: no goals
Theorem: Equiv.Perm.get_toList
File: Mathlib/GroupTheory/Perm/Cycle/Concrete.lean

tactic: simp [toList]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x : α
n : ℕ
hn : n < (p.toList x).length
⊢ (p.toList x).get ⟨n, hn⟩ = (p ^ n) x
state_after: no goals
Theorem: Asymptotics.superpolynomialDecay_mul_param_iff
File: Mathlib/Analysis/Asymptotics/SuperpolynomialDecay.lean

tactic: simpa [mul_comm k] using superpolynomialDecay_param_mul_iff f hk
state_before: α : Type u_1
β : Type u_2
l : Filter α
k f g g' : α → β
inst✝² : TopologicalSpace β
inst✝¹ : LinearOrderedField β
inst✝ : OrderTopology β
hk : Tendsto k l atTop
⊢ SuperpolynomialDecay l k (f * k) ↔ SuperpolynomialDecay l k f
state_after: no goals
Theorem: Polynomial.update_eq_add_sub_coeff
File: Mathlib/Algebra/Polynomial/Coeff.lean

tactic: ext
state_before: R✝ : Type u
S : Type v
a✝ b : R✝
n✝ m : ℕ
inst✝¹ : Semiring R✝
p✝ q r : R✝[X]
R : Type u_1
inst✝ : Ring R
p : R[X]
n : ℕ
a : R
⊢ p.update n a = p + C (a - p.coeff n) * X ^ n
state_after: case a
R✝ : Type u
S : Type v
a✝ b : R✝
n✝¹ m : ℕ
inst✝¹ : Semiring R✝
p✝ q r : R✝[X]
R : Type u_1
inst✝ : Ring R
p : R[X]
n : ℕ
a : R
n✝ : ℕ
⊢ (p.update n a).coeff n✝ = (p + C (a - p.coeff n) * X ^ n).coeff n✝

tactic: rw [coeff_update_apply, coeff_add, coeff_C_mul_X_pow]
state_before: case a
R✝ : Type u
S : Type v
a✝ b : R✝
n✝¹ m : ℕ
inst✝¹ : Semiring R✝
p✝ q r : R✝[X]
R : Type u_1
inst✝ : Ring R
p : R[X]
n : ℕ
a : R
n✝ : ℕ
⊢ (p.update n a).coeff n✝ = (p + C (a - p.coeff n) * X ^ n).coeff n✝
state_after: case a
R✝ : Type u
S : Type v
a✝ b : R✝
n✝¹ m : ℕ
inst✝¹ : Semiring R✝
p✝ q r : R✝[X]
R : Type u_1
inst✝ : Ring R
p : R[X]
n : ℕ
a : R
n✝ : ℕ
⊢ (if n✝ = n then a else p.coeff n✝) = p.coeff n✝ + if n✝ = n then a - p.coeff n else 0

tactic: split_ifs with h <;> simp [h]
state_before: case a
R✝ : Type u
S : Type v
a✝ b : R✝
n✝¹ m : ℕ
inst✝¹ : Semiring R✝
p✝ q r : R✝[X]
R : Type u_1
inst✝ : Ring R
p : R[X]
n : ℕ
a : R
n✝ : ℕ
⊢ (if n✝ = n then a else p.coeff n✝) = p.coeff n✝ + if n✝ = n then a - p.coeff n else 0
state_after: no goals
Theorem: LinearEquiv.det_symm_mul_det
File: Mathlib/LinearAlgebra/Determinant.lean

tactic: simp [← LinearMap.det_comp]
state_before: R : Type u_1
inst✝⁸ : CommRing R
M : Type u_2
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
M' : Type u_3
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M'
ι : Type u_4
inst✝³ : DecidableEq ι
inst✝² : Fintype ι
e : Basis ι R M
A : Type u_5
inst✝¹ : CommRing A
inst✝ : Module A M
f : M ≃ₗ[A] M
⊢ LinearMap.det ↑f.symm * LinearMap.det ↑f = 1
state_after: no goals
Theorem: Codisjoint.himp_inf_cancel_left
File: Mathlib/Order/Heyting/Basic.lean

tactic: rw [himp_inf_distrib, himp_self, inf_top_eq, h.himp_eq_right]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : GeneralizedHeytingAlgebra α
a b c d : α
h : Codisjoint a b
⊢ b ⇨ a ⊓ b = a
state_after: no goals
Theorem: hasFDerivWithinAt_congr_set'
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

tactic: suffices 𝓝[s \ {y}] x = 𝓝[t \ {y}] x by simp only [HasFDerivWithinAt, this]
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
y : E
h : s =ᶠ[𝓝[{y}ᶜ] x] t
⊢ HasFDerivWithinAt f f' (s \ {y}) x ↔ HasFDerivWithinAt f f' (t \ {y}) x
state_after: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
y : E
h : s =ᶠ[𝓝[{y}ᶜ] x] t
⊢ 𝓝[s \ {y}] x = 𝓝[t \ {y}] x

tactic: simpa only [set_eventuallyEq_iff_inf_principal, ← nhdsWithin_inter', diff_eq,
  inter_comm] using h
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
y : E
h : s =ᶠ[𝓝[{y}ᶜ] x] t
⊢ 𝓝[s \ {y}] x = 𝓝[t \ {y}] x
state_after: no goals

tactic: simp only [HasFDerivWithinAt, this]
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
y : E
h : s =ᶠ[𝓝[{y}ᶜ] x] t
this : 𝓝[s \ {y}] x = 𝓝[t \ {y}] x
⊢ HasFDerivWithinAt f f' (s \ {y}) x ↔ HasFDerivWithinAt f f' (t \ {y}) x
state_after: no goals