1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: IsLocalization.Away.auxHom_auxInv
File: Mathlib/RingTheory/MvPolynomial/Localization.lean

tactic: apply IsLocalization.ringHom_ext (Submonoid.powers r)
state_before: σ : Type u_1
R : Type u_2
inst✝³ : CommRing R
M : Submonoid R
S : Type u_3
inst✝² : CommRing S
inst✝¹ : Algebra R S
r : R
inst✝ : Away r S
⊢ (IsLocalization.Away.auxHom S r).comp (IsLocalization.Away.auxInv S r) = RingHom.id S
state_after: case h
σ : Type u_1
R : Type u_2
inst✝³ : CommRing R
M : Submonoid R
S : Type u_3
inst✝² : CommRing S
inst✝¹ : Algebra R S
r : R
inst✝ : Away r S
⊢ ((IsLocalization.Away.auxHom S r).comp (IsLocalization.Away.auxInv S r)).comp (algebraMap R S) =
    (RingHom.id S).comp (algebraMap R S)

tactic: ext x
state_before: case h
σ : Type u_1
R : Type u_2
inst✝³ : CommRing R
M : Submonoid R
S : Type u_3
inst✝² : CommRing S
inst✝¹ : Algebra R S
r : R
inst✝ : Away r S
⊢ ((IsLocalization.Away.auxHom S r).comp (IsLocalization.Away.auxInv S r)).comp (algebraMap R S) =
    (RingHom.id S).comp (algebraMap R S)
state_after: case h.a
σ : Type u_1
R : Type u_2
inst✝³ : CommRing R
M : Submonoid R
S : Type u_3
inst✝² : CommRing S
inst✝¹ : Algebra R S
r : R
inst✝ : Away r S
x : R
⊢ (((IsLocalization.Away.auxHom S r).comp (IsLocalization.Away.auxInv S r)).comp (algebraMap R S)) x =
    ((RingHom.id S).comp (algebraMap R S)) x

tactic: simp [auxInv]
state_before: case h.a
σ : Type u_1
R : Type u_2
inst✝³ : CommRing R
M : Submonoid R
S : Type u_3
inst✝² : CommRing S
inst✝¹ : Algebra R S
r : R
inst✝ : Away r S
x : R
⊢ (((IsLocalization.Away.auxHom S r).comp (IsLocalization.Away.auxInv S r)).comp (algebraMap R S)) x =
    ((RingHom.id S).comp (algebraMap R S)) x
state_after: no goals
Theorem: Nat.cast_choose
File: Mathlib/Data/Nat/Choose/Cast.lean

tactic: have : ∀ {n : ℕ}, (n ! : K) ≠ 0 := Nat.cast_ne_zero.2 (factorial_ne_zero _)
state_before: K : Type u_1
inst✝¹ : DivisionRing K
inst✝ : CharZero K
a b : ℕ
h : a ≤ b
⊢ ↑(b.choose a) = ↑b ! / (↑a ! * ↑(b - a)!)
state_after: K : Type u_1
inst✝¹ : DivisionRing K
inst✝ : CharZero K
a b : ℕ
h : a ≤ b
this : ∀ {n : ℕ}, ↑n ! ≠ 0
⊢ ↑(b.choose a) = ↑b ! / (↑a ! * ↑(b - a)!)

tactic: rw [eq_div_iff_mul_eq (mul_ne_zero this this)]
state_before: K : Type u_1
inst✝¹ : DivisionRing K
inst✝ : CharZero K
a b : ℕ
h : a ≤ b
this : ∀ {n : ℕ}, ↑n ! ≠ 0
⊢ ↑(b.choose a) = ↑b ! / (↑a ! * ↑(b - a)!)
state_after: K : Type u_1
inst✝¹ : DivisionRing K
inst✝ : CharZero K
a b : ℕ
h : a ≤ b
this : ∀ {n : ℕ}, ↑n ! ≠ 0
⊢ ↑(b.choose a) * (↑a ! * ↑(b - a)!) = ↑b !

tactic: rw_mod_cast [← mul_assoc, choose_mul_factorial_mul_factorial h]
state_before: K : Type u_1
inst✝¹ : DivisionRing K
inst✝ : CharZero K
a b : ℕ
h : a ≤ b
this : ∀ {n : ℕ}, ↑n ! ≠ 0
⊢ ↑(b.choose a) * (↑a ! * ↑(b - a)!) = ↑b !
state_after: no goals
Theorem: Matrix.Pivot.listTransvecCol_mul_last_row
File: Mathlib/LinearAlgebra/Matrix/Transvection.lean

tactic: simpa using listTransvecCol_mul_last_row_drop M i (zero_le _)
state_before: n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝³ : Field 𝕜
inst✝² : DecidableEq n
inst✝¹ : DecidableEq p
inst✝ : CommRing R
r : ℕ
M : Matrix (Fin r ⊕ Unit) (Fin r ⊕ Unit) 𝕜
i : Fin r ⊕ Unit
⊢ ((listTransvecCol M).prod * M) (inr ()) i = M (inr ()) i
state_after: no goals
Theorem: List.Palindrome.map
File: Mathlib/Data/List/Palindrome.lean

tactic: rw [← map_reverse, p.reverse_eq]
state_before: α : Type u_1
β : Type u_2
l : List α
f : α → β
p : l.Palindrome
⊢ (map f l).reverse = map f l
state_after: no goals
Theorem: Heyting.IsRegular.himp
File: Mathlib/Order/Heyting/Regular.lean

tactic: rw [IsRegular, compl_compl_himp_distrib, ha.eq, hb.eq]
state_before: α : Type u_1
inst✝ : HeytingAlgebra α
a b : α
ha : IsRegular a
hb : IsRegular b
⊢ IsRegular (a ⇨ b)
state_after: no goals
Theorem: MultilinearMap.alternization_map_eq_zero_of_eq_aux
File: Mathlib/LinearAlgebra/Alternating/Basic.lean

tactic: rw [sum_apply]
state_before: R : Type u_1
inst✝¹² : Semiring R
M : Type u_2
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : Module R M
N : Type u_3
inst✝⁹ : AddCommMonoid N
inst✝⁸ : Module R N
P : Type u_4
inst✝⁷ : AddCommMonoid P
inst✝⁶ : Module R P
M' : Type u_5
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M'
N' : Type u_6
inst✝³ : AddCommGroup N'
inst✝² : Module R N'
ι : Type u_7
ι' : Type u_8
ι'' : Type u_9
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
m : MultilinearMap R (fun x => M) N'
v : ι → M
i j : ι
i_ne_j : i ≠ j
hv : v i = v j
⊢ (∑ σ : Perm ι, Perm.sign σ • domDomCongr σ m) v = 0
state_after: R : Type u_1
inst✝¹² : Semiring R
M : Type u_2
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : Module R M
N : Type u_3
inst✝⁹ : AddCommMonoid N
inst✝⁸ : Module R N
P : Type u_4
inst✝⁷ : AddCommMonoid P
inst✝⁶ : Module R P
M' : Type u_5
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M'
N' : Type u_6
inst✝³ : AddCommGroup N'
inst✝² : Module R N'
ι : Type u_7
ι' : Type u_8
ι'' : Type u_9
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
m : MultilinearMap R (fun x => M) N'
v : ι → M
i j : ι
i_ne_j : i ≠ j
hv : v i = v j
⊢ ∑ a : Perm ι, (Perm.sign a • domDomCongr a m) v = 0

tactic: exact
  Finset.sum_involution (fun σ _ => swap i j * σ)
    (fun σ _ => by simp [Perm.sign_swap i_ne_j, apply_swap_eq_self hv, -Equiv.Perm.sign_swap'])
    (fun σ _ _ => (not_congr swap_mul_eq_iff).mpr i_ne_j) (fun σ _ => Finset.mem_univ _)
    fun σ _ => swap_mul_involutive i j σ
state_before: R : Type u_1
inst✝¹² : Semiring R
M : Type u_2
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : Module R M
N : Type u_3
inst✝⁹ : AddCommMonoid N
inst✝⁸ : Module R N
P : Type u_4
inst✝⁷ : AddCommMonoid P
inst✝⁶ : Module R P
M' : Type u_5
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M'
N' : Type u_6
inst✝³ : AddCommGroup N'
inst✝² : Module R N'
ι : Type u_7
ι' : Type u_8
ι'' : Type u_9
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
m : MultilinearMap R (fun x => M) N'
v : ι → M
i j : ι
i_ne_j : i ≠ j
hv : v i = v j
⊢ ∑ a : Perm ι, (Perm.sign a • domDomCongr a m) v = 0
state_after: no goals

tactic: simp [Perm.sign_swap i_ne_j, apply_swap_eq_self hv, -Equiv.Perm.sign_swap']
state_before: R : Type u_1
inst✝¹² : Semiring R
M : Type u_2
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : Module R M
N : Type u_3
inst✝⁹ : AddCommMonoid N
inst✝⁸ : Module R N
P : Type u_4
inst✝⁷ : AddCommMonoid P
inst✝⁶ : Module R P
M' : Type u_5
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M'
N' : Type u_6
inst✝³ : AddCommGroup N'
inst✝² : Module R N'
ι : Type u_7
ι' : Type u_8
ι'' : Type u_9
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
m : MultilinearMap R (fun x => M) N'
v : ι → M
i j : ι
i_ne_j : i ≠ j
hv : v i = v j
σ : Perm ι
x✝ : σ ∈ Finset.univ
⊢ (Perm.sign σ • domDomCongr σ m) v +
      (Perm.sign ((fun σ x => swap i j * σ) σ x✝) • domDomCongr ((fun σ x => swap i j * σ) σ x✝) m) v =
    0
state_after: no goals
Theorem: List.lookupAll_eq_nil
File: Mathlib/Data/List/Sigma.lean

tactic: simp
state_before: α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
⊢ lookupAll a [] = [] ↔ ∀ (b : β a), ⟨a, b⟩ ∉ []
state_after: no goals

tactic: by_cases h : a = a'
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
b : β a'
l : List (Sigma β)
⊢ lookupAll a (⟨a', b⟩ :: l) = [] ↔ ∀ (b_1 : β a), ⟨a, b_1⟩ ∉ ⟨a', b⟩ :: l
state_after: case pos
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
b : β a'
l : List (Sigma β)
h : a = a'
⊢ lookupAll a (⟨a', b⟩ :: l) = [] ↔ ∀ (b_1 : β a), ⟨a, b_1⟩ ∉ ⟨a', b⟩ :: l

case neg
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
b : β a'
l : List (Sigma β)
h : ¬a = a'
⊢ lookupAll a (⟨a', b⟩ :: l) = [] ↔ ∀ (b_1 : β a), ⟨a, b_1⟩ ∉ ⟨a', b⟩ :: l

tactic: subst a'
state_before: case pos
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
b : β a'
l : List (Sigma β)
h : a = a'
⊢ lookupAll a (⟨a', b⟩ :: l) = [] ↔ ∀ (b_1 : β a), ⟨a, b_1⟩ ∉ ⟨a', b⟩ :: l
state_after: case pos
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
b : β a
⊢ lookupAll a (⟨a, b⟩ :: l) = [] ↔ ∀ (b_1 : β a), ⟨a, b_1⟩ ∉ ⟨a, b⟩ :: l

tactic: simp only [lookupAll_cons_eq, mem_cons, Sigma.mk.inj_iff, heq_eq_eq, true_and, not_or,
  false_iff, not_forall, not_and, not_not]
state_before: case pos
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
b : β a
⊢ lookupAll a (⟨a, b⟩ :: l) = [] ↔ ∀ (b_1 : β a), ⟨a, b_1⟩ ∉ ⟨a, b⟩ :: l
state_after: case pos
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
b : β a
⊢ ∃ x, ¬x = b → ⟨a, x⟩ ∈ l

tactic: use b
state_before: case pos
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
b : β a
⊢ ∃ x, ¬x = b → ⟨a, x⟩ ∈ l
state_after: case h
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
b : β a
⊢ ¬b = b → ⟨a, b⟩ ∈ l

tactic: simp
state_before: case h
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
b : β a
⊢ ¬b = b → ⟨a, b⟩ ∈ l
state_after: no goals

tactic: simp [h, lookupAll_eq_nil]
state_before: case neg
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
b : β a'
l : List (Sigma β)
h : ¬a = a'
⊢ lookupAll a (⟨a', b⟩ :: l) = [] ↔ ∀ (b_1 : β a), ⟨a, b_1⟩ ∉ ⟨a', b⟩ :: l
state_after: no goals
Theorem: EReal.strictAnti_div_right_of_neg
File: Mathlib/Data/Real/EReal.lean

tactic: intro a a' a_lt_a'
state_before: b : EReal
h : b < 0
h' : b ≠ ⊥
⊢ StrictAnti fun a => a / b
state_after: b : EReal
h : b < 0
h' : b ≠ ⊥
a a' : EReal
a_lt_a' : a < a'
⊢ (fun a => a / b) a' < (fun a => a / b) a

tactic: simp only
state_before: b : EReal
h : b < 0
h' : b ≠ ⊥
a a' : EReal
a_lt_a' : a < a'
⊢ (fun a => a / b) a' < (fun a => a / b) a
state_after: b : EReal
h : b < 0
h' : b ≠ ⊥
a a' : EReal
a_lt_a' : a < a'
⊢ a' / b < a / b

tactic: apply lt_of_le_of_ne <| div_le_div_right_of_nonpos (le_of_lt h) (le_of_lt a_lt_a')
state_before: b : EReal
h : b < 0
h' : b ≠ ⊥
a a' : EReal
a_lt_a' : a < a'
⊢ a' / b < a / b
state_after: b : EReal
h : b < 0
h' : b ≠ ⊥
a a' : EReal
a_lt_a' : a < a'
⊢ a' / b ≠ a / b

tactic: intro hyp
state_before: b : EReal
h : b < 0
h' : b ≠ ⊥
a a' : EReal
a_lt_a' : a < a'
⊢ a' / b ≠ a / b
state_after: b : EReal
h : b < 0
h' : b ≠ ⊥
a a' : EReal
a_lt_a' : a < a'
hyp : a' / b = a / b
⊢ False

tactic: apply ne_of_lt a_lt_a'
state_before: b : EReal
h : b < 0
h' : b ≠ ⊥
a a' : EReal
a_lt_a' : a < a'
hyp : a' / b = a / b
⊢ False
state_after: b : EReal
h : b < 0
h' : b ≠ ⊥
a a' : EReal
a_lt_a' : a < a'
hyp : a' / b = a / b
⊢ a = a'

tactic: rw [← @EReal.mul_div_cancel a b h' (ne_top_of_lt h) (ne_of_lt h), ← hyp,
  @EReal.mul_div_cancel a' b h' (ne_top_of_lt h) (ne_of_lt h)]
state_before: b : EReal
h : b < 0
h' : b ≠ ⊥
a a' : EReal
a_lt_a' : a < a'
hyp : a' / b = a / b
⊢ a = a'
state_after: no goals
Theorem: tsub_one_mul
File: Mathlib/Algebra/Order/Ring/Canonical.lean

tactic: rw [tsub_mul, one_mul]
state_before: α : Type u
β : Type u_1
inst✝⁴ : CanonicallyOrderedCommSemiring α
a✝ b✝ c : α
inst✝³ : Sub α
inst✝² : OrderedSub α
inst✝¹ : IsTotal α fun x x_1 => x ≤ x_1
inst✝ : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a b : α
⊢ (a - 1) * b = a * b - b
state_after: no goals
Theorem: ProbabilityTheory.kernel.finset_sum_apply'
File: Mathlib/Probability/Kernel/Basic.lean

tactic: rw [finset_sum_apply, Measure.finset_sum_apply]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
I : Finset ι
κ : ι → ↥(kernel α β)
a : α
s : Set β
⊢ ((∑ i ∈ I, κ i) a) s = ∑ i ∈ I, ((κ i) a) s
state_after: no goals
Theorem: IsLindelof.inter_right
File: Mathlib/Topology/Compactness/Lindelof.lean

tactic: intro f hnf _ hstf
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
hs : IsLindelof s
ht : IsClosed t
⊢ IsLindelof (s ∩ t)
state_after: X : Type u
Y : Type v
ι : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t : Set X
hs : IsLindelof s
ht : IsClosed t
f : Filter X
hnf : f.NeBot
inst✝ : CountableInterFilter f
hstf : f ≤ 𝓟 (s ∩ t)
⊢ ∃ x ∈ s ∩ t, ClusterPt x f

tactic: rw [← inf_principal, le_inf_iff] at hstf
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t : Set X
hs : IsLindelof s
ht : IsClosed t
f : Filter X
hnf : f.NeBot
inst✝ : CountableInterFilter f
hstf : f ≤ 𝓟 (s ∩ t)
⊢ ∃ x ∈ s ∩ t, ClusterPt x f
state_after: X : Type u
Y : Type v
ι : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t : Set X
hs : IsLindelof s
ht : IsClosed t
f : Filter X
hnf : f.NeBot
inst✝ : CountableInterFilter f
hstf : f ≤ 𝓟 s ∧ f ≤ 𝓟 t
⊢ ∃ x ∈ s ∩ t, ClusterPt x f

tactic: obtain ⟨x, hsx, hx⟩ : ∃ x ∈ s, ClusterPt x f := hs hstf.1
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t : Set X
hs : IsLindelof s
ht : IsClosed t
f : Filter X
hnf : f.NeBot
inst✝ : CountableInterFilter f
hstf : f ≤ 𝓟 s ∧ f ≤ 𝓟 t
⊢ ∃ x ∈ s ∩ t, ClusterPt x f
state_after: case intro.intro
X : Type u
Y : Type v
ι : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t : Set X
hs : IsLindelof s
ht : IsClosed t
f : Filter X
hnf : f.NeBot
inst✝ : CountableInterFilter f
hstf : f ≤ 𝓟 s ∧ f ≤ 𝓟 t
x : X
hsx : x ∈ s
hx : ClusterPt x f
⊢ ∃ x ∈ s ∩ t, ClusterPt x f

tactic: have hxt : x ∈ t := ht.mem_of_nhdsWithin_neBot <| hx.mono hstf.2
state_before: case intro.intro
X : Type u
Y : Type v
ι : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t : Set X
hs : IsLindelof s
ht : IsClosed t
f : Filter X
hnf : f.NeBot
inst✝ : CountableInterFilter f
hstf : f ≤ 𝓟 s ∧ f ≤ 𝓟 t
x : X
hsx : x ∈ s
hx : ClusterPt x f
⊢ ∃ x ∈ s ∩ t, ClusterPt x f
state_after: case intro.intro
X : Type u
Y : Type v
ι : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t : Set X
hs : IsLindelof s
ht : IsClosed t
f : Filter X
hnf : f.NeBot
inst✝ : CountableInterFilter f
hstf : f ≤ 𝓟 s ∧ f ≤ 𝓟 t
x : X
hsx : x ∈ s
hx : ClusterPt x f
hxt : x ∈ t
⊢ ∃ x ∈ s ∩ t, ClusterPt x f

tactic: exact ⟨x, ⟨hsx, hxt⟩, hx⟩
state_before: case intro.intro
X : Type u
Y : Type v
ι : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t : Set X
hs : IsLindelof s
ht : IsClosed t
f : Filter X
hnf : f.NeBot
inst✝ : CountableInterFilter f
hstf : f ≤ 𝓟 s ∧ f ≤ 𝓟 t
x : X
hsx : x ∈ s
hx : ClusterPt x f
hxt : x ∈ t
⊢ ∃ x ∈ s ∩ t, ClusterPt x f
state_after: no goals
Theorem: Basis.repr_sum_self
File: Mathlib/LinearAlgebra/Basis.lean

tactic: simp_rw [← b.equivFun_symm_apply, ← b.equivFun_apply, b.equivFun.apply_symm_apply]
state_before: ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : AddCommMonoid M'
inst✝¹ : Module R M'
inst✝ : Fintype ι
b : Basis ι R M
c : ι → R
⊢ ⇑(b.repr (∑ i : ι, c i • b i)) = c
state_after: no goals
Theorem: Batteries.RBNode.exists_insert_toList_zoom_node
File: .lake/packages/batteries/Batteries/Data/RBMap/Lemmas.lean

tactic: refine ⟨p.listL ++ l.toList, r.toList ++ p.listR, ?_⟩
state_before: α : Type u_1
c : RBColor
n : Nat
cmp : α → α → Ordering
c' : RBColor
l : RBNode α
v' : α
r : RBNode α
p : Path α
v : α
t : RBNode α
ht : t.Balanced c n
e : zoom (cmp v) t = (node c' l v' r, p)
⊢ ∃ L R, t.toList = L ++ v' :: R ∧ (insert cmp t v).toList = L ++ v :: R
state_after: α : Type u_1
c : RBColor
n : Nat
cmp : α → α → Ordering
c' : RBColor
l : RBNode α
v' : α
r : RBNode α
p : Path α
v : α
t : RBNode α
ht : t.Balanced c n
e : zoom (cmp v) t = (node c' l v' r, p)
⊢ t.toList = p.listL ++ l.toList ++ v' :: (r.toList ++ p.listR) ∧
    (insert cmp t v).toList = p.listL ++ l.toList ++ v :: (r.toList ++ p.listR)

tactic: simp [← zoom_toList e, insert_toList_zoom_node ht e]
state_before: α : Type u_1
c : RBColor
n : Nat
cmp : α → α → Ordering
c' : RBColor
l : RBNode α
v' : α
r : RBNode α
p : Path α
v : α
t : RBNode α
ht : t.Balanced c n
e : zoom (cmp v) t = (node c' l v' r, p)
⊢ t.toList = p.listL ++ l.toList ++ v' :: (r.toList ++ p.listR) ∧
    (insert cmp t v).toList = p.listL ++ l.toList ++ v :: (r.toList ++ p.listR)
state_after: no goals
Theorem: Finmap.keysLookupEquiv_symm_apply_keys
File: Mathlib/Data/Finmap.lean

tactic: simp only [Equiv.symm_apply_apply, keysLookupEquiv_apply_coe_fst]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
x✝ : Finmap β
⊢ (keysLookupEquiv.symm (keysLookupEquiv x✝)).keys = (↑(keysLookupEquiv x✝)).1
state_after: no goals
Theorem: AlgebraicGeometry.ProjectiveSpectrum.Proj.toOpen_toSpec_val_c_app
File: Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Scheme.lean

tactic: congr
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
U : (Opens ↑↑(Spec A⁰_ f).toPresheafedSpace)ᵒᵖ
⊢ StructureSheaf.toOpen (A⁰_ f) U.unop ≫ (toSpec 𝒜 f).val.c.app U =
    StructureSheaf.toOpen (A⁰_ f) U.unop ≫
      ((ΓSpec.locallyRingedSpaceAdjunction.homEquiv (Proj.restrict ⋯) { unop := CommRingCat.of (A⁰_ f) })
                (awayToΓ 𝒜 f).op).val.c.app
        U
state_after: no goals
Theorem: List.sorted_mergeSort
File: Mathlib/Data/List/Sort.lean

tactic: simp [mergeSort]
state_before: α : Type u
r : α → α → Prop
inst✝² : DecidableRel r
inst✝¹ : IsTotal α r
inst✝ : IsTrans α r
⊢ Sorted r (mergeSort r [])
state_after: no goals

tactic: simp [mergeSort]
state_before: α : Type u
r : α → α → Prop
inst✝² : DecidableRel r
inst✝¹ : IsTotal α r
inst✝ : IsTrans α r
a : α
⊢ Sorted r (mergeSort r [a])
state_after: no goals

tactic: cases' e : split (a :: b :: l) with l₁ l₂
state_before: α : Type u
r : α → α → Prop
inst✝² : DecidableRel r
inst✝¹ : IsTotal α r
inst✝ : IsTrans α r
a b : α
l : List α
⊢ Sorted r (mergeSort r (a :: b :: l))
state_after: case mk
α : Type u
r : α → α → Prop
inst✝² : DecidableRel r
inst✝¹ : IsTotal α r
inst✝ : IsTrans α r
a b : α
l l₁ l₂ : List α
e : (a :: b :: l).split = (l₁, l₂)
⊢ Sorted r (mergeSort r (a :: b :: l))

tactic: cases' length_split_lt e with h₁ h₂
state_before: case mk
α : Type u
r : α → α → Prop
inst✝² : DecidableRel r
inst✝¹ : IsTotal α r
inst✝ : IsTrans α r
a b : α
l l₁ l₂ : List α
e : (a :: b :: l).split = (l₁, l₂)
⊢ Sorted r (mergeSort r (a :: b :: l))
state_after: case mk.intro
α : Type u
r : α → α → Prop
inst✝² : DecidableRel r
inst✝¹ : IsTotal α r
inst✝ : IsTrans α r
a b : α
l l₁ l₂ : List α
e : (a :: b :: l).split = (l₁, l₂)
h₁ : l₁.length < (a :: b :: l).length
h₂ : l₂.length < (a :: b :: l).length
⊢ Sorted r (mergeSort r (a :: b :: l))

tactic: rw [mergeSort_cons_cons r e]
state_before: case mk.intro
α : Type u
r : α → α → Prop
inst✝² : DecidableRel r
inst✝¹ : IsTotal α r
inst✝ : IsTrans α r
a b : α
l l₁ l₂ : List α
e : (a :: b :: l).split = (l₁, l₂)
h₁ : l₁.length < (a :: b :: l).length
h₂ : l₂.length < (a :: b :: l).length
⊢ Sorted r (mergeSort r (a :: b :: l))
state_after: case mk.intro
α : Type u
r : α → α → Prop
inst✝² : DecidableRel r
inst✝¹ : IsTotal α r
inst✝ : IsTrans α r
a b : α
l l₁ l₂ : List α
e : (a :: b :: l).split = (l₁, l₂)
h₁ : l₁.length < (a :: b :: l).length
h₂ : l₂.length < (a :: b :: l).length
⊢ Sorted r (merge (fun x x_1 => decide (r x x_1)) (mergeSort r l₁) (mergeSort r l₂))

tactic: exact (sorted_mergeSort l₁).merge (sorted_mergeSort l₂)
state_before: case mk.intro
α : Type u
r : α → α → Prop
inst✝² : DecidableRel r
inst✝¹ : IsTotal α r
inst✝ : IsTrans α r
a b : α
l l₁ l₂ : List α
e : (a :: b :: l).split = (l₁, l₂)
h₁ : l₁.length < (a :: b :: l).length
h₂ : l₂.length < (a :: b :: l).length
⊢ Sorted r (merge (fun x x_1 => decide (r x x_1)) (mergeSort r l₁) (mergeSort r l₂))
state_after: no goals
Theorem: MeasureTheory.ae_restrict_eq
File: Mathlib/MeasureTheory/Measure/Restrict.lean

tactic: ext t
state_before: R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
hs : MeasurableSet s
⊢ ae (μ.restrict s) = ae μ ⊓ 𝓟 s
state_after: case a
R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t✝ : Set α
hs : MeasurableSet s
t : Set α
⊢ t ∈ ae (μ.restrict s) ↔ t ∈ ae μ ⊓ 𝓟 s

tactic: simp only [mem_inf_principal, mem_ae_iff, restrict_apply_eq_zero' hs, compl_setOf,
  Classical.not_imp, fun a => and_comm (a := a ∈ s) (b := ¬a ∈ t)]
state_before: case a
R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t✝ : Set α
hs : MeasurableSet s
t : Set α
⊢ t ∈ ae (μ.restrict s) ↔ t ∈ ae μ ⊓ 𝓟 s
state_after: case a
R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t✝ : Set α
hs : MeasurableSet s
t : Set α
⊢ μ (tᶜ ∩ s) = 0 ↔ μ {a | a ∉ t ∧ a ∈ s} = 0

tactic: rfl
state_before: case a
R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t✝ : Set α
hs : MeasurableSet s
t : Set α
⊢ μ (tᶜ ∩ s) = 0 ↔ μ {a | a ∉ t ∧ a ∈ s} = 0
state_after: no goals
Theorem: Homeomorph.image_closure
File: Mathlib/Topology/Homeomorph.lean

tactic: rw [← preimage_symm, preimage_closure]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
X' : Type u_4
Y' : Type u_5
inst✝¹ : TopologicalSpace X'
inst✝ : TopologicalSpace Y'
h : X ≃ₜ Y
s : Set X
⊢ ⇑h '' closure s = closure (⇑h '' s)
state_after: no goals
Theorem: char_dvd_card_solutions_of_fintype_sum_lt
File: Mathlib/FieldTheory/ChevalleyWarning.lean

tactic: simpa using char_dvd_card_solutions_of_sum_lt p h
state_before: K : Type u_1
σ : Type u_2
ι : Type u_3
inst✝⁶ : Fintype K
inst✝⁵ : Field K
inst✝⁴ : Fintype σ
inst✝³ : DecidableEq σ
inst✝² : DecidableEq K
p : ℕ
inst✝¹ : CharP K p
inst✝ : Fintype ι
f : ι → MvPolynomial σ K
h : ∑ i : ι, (f i).totalDegree < Fintype.card σ
⊢ p ∣ Fintype.card { x // ∀ (i : ι), (eval x) (f i) = 0 }
state_after: no goals