1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Nat.unpair_lt
File: Mathlib/Data/Nat/Pairing.lean

tactic: let s := sqrt n
state_before: n : ℕ
n1 : 1 ≤ n
⊢ (unpair n).1 < n
state_after: n : ℕ
n1 : 1 ≤ n
s : ℕ := n.sqrt
⊢ (unpair n).1 < n

tactic: simp only [unpair, ge_iff_le, Nat.sub_le_iff_le_add]
state_before: n : ℕ
n1 : 1 ≤ n
s : ℕ := n.sqrt
⊢ (unpair n).1 < n
state_after: n : ℕ
n1 : 1 ≤ n
s : ℕ := n.sqrt
⊢ (if n - n.sqrt * n.sqrt < n.sqrt then (n - n.sqrt * n.sqrt, n.sqrt) else (n.sqrt, n - n.sqrt * n.sqrt - n.sqrt)).1 < n

tactic: by_cases h : n - s * s < s <;> simp [h]
state_before: n : ℕ
n1 : 1 ≤ n
s : ℕ := n.sqrt
⊢ (if n - n.sqrt * n.sqrt < n.sqrt then (n - n.sqrt * n.sqrt, n.sqrt) else (n.sqrt, n - n.sqrt * n.sqrt - n.sqrt)).1 < n
state_after: case pos
n : ℕ
n1 : 1 ≤ n
s : ℕ := n.sqrt
h : n - s * s < s
⊢ n - n.sqrt * n.sqrt < n

case neg
n : ℕ
n1 : 1 ≤ n
s : ℕ := n.sqrt
h : ¬n - s * s < s
⊢ n.sqrt < n

tactic: exact lt_of_lt_of_le h (sqrt_le_self _)
state_before: case pos
n : ℕ
n1 : 1 ≤ n
s : ℕ := n.sqrt
h : n - s * s < s
⊢ n - n.sqrt * n.sqrt < n
state_after: no goals

tactic: simp at h
state_before: case neg
n : ℕ
n1 : 1 ≤ n
s : ℕ := n.sqrt
h : ¬n - s * s < s
⊢ n.sqrt < n
state_after: case neg
n : ℕ
n1 : 1 ≤ n
s : ℕ := n.sqrt
h : s ≤ n - s * s
⊢ n.sqrt < n

tactic: have s0 : 0 < s := sqrt_pos.2 n1
state_before: case neg
n : ℕ
n1 : 1 ≤ n
s : ℕ := n.sqrt
h : s ≤ n - s * s
⊢ n.sqrt < n
state_after: case neg
n : ℕ
n1 : 1 ≤ n
s : ℕ := n.sqrt
h : s ≤ n - s * s
s0 : 0 < s
⊢ n.sqrt < n

tactic: exact lt_of_le_of_lt h (Nat.sub_lt n1 (Nat.mul_pos s0 s0))
state_before: case neg
n : ℕ
n1 : 1 ≤ n
s : ℕ := n.sqrt
h : s ≤ n - s * s
s0 : 0 < s
⊢ n.sqrt < n
state_after: no goals
Theorem: Fin.exists_eq_add_of_le
File: Mathlib/Data/Fin/Basic.lean

tactic: obtain ⟨k, hk⟩ : ∃ k : ℕ, (b : ℕ) = a + k := Nat.exists_eq_add_of_le h
state_before: n✝ m n : ℕ
a b : Fin n
h : a ≤ b
⊢ ∃ k ≤ b, b = a + k
state_after: case intro
n✝ m n : ℕ
a b : Fin n
h : a ≤ b
k : ℕ
hk : ↑b = ↑a + k
⊢ ∃ k ≤ b, b = a + k

tactic: have hkb : k ≤ b := by omega
state_before: case intro
n✝ m n : ℕ
a b : Fin n
h : a ≤ b
k : ℕ
hk : ↑b = ↑a + k
⊢ ∃ k ≤ b, b = a + k
state_after: case intro
n✝ m n : ℕ
a b : Fin n
h : a ≤ b
k : ℕ
hk : ↑b = ↑a + k
hkb : k ≤ ↑b
⊢ ∃ k ≤ b, b = a + k

tactic: refine ⟨⟨k, hkb.trans_lt b.is_lt⟩, hkb, ?_⟩
state_before: case intro
n✝ m n : ℕ
a b : Fin n
h : a ≤ b
k : ℕ
hk : ↑b = ↑a + k
hkb : k ≤ ↑b
⊢ ∃ k ≤ b, b = a + k
state_after: case intro
n✝ m n : ℕ
a b : Fin n
h : a ≤ b
k : ℕ
hk : ↑b = ↑a + k
hkb : k ≤ ↑b
⊢ b = a + ⟨k, ⋯⟩

tactic: simp [Fin.ext_iff, Fin.val_add, ← hk, Nat.mod_eq_of_lt b.is_lt]
state_before: case intro
n✝ m n : ℕ
a b : Fin n
h : a ≤ b
k : ℕ
hk : ↑b = ↑a + k
hkb : k ≤ ↑b
⊢ b = a + ⟨k, ⋯⟩
state_after: no goals

tactic: omega
state_before: n✝ m n : ℕ
a b : Fin n
h : a ≤ b
k : ℕ
hk : ↑b = ↑a + k
⊢ k ≤ ↑b
state_after: no goals
Theorem: MeasureTheory.memℒp_one_iff_integrable
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: simp_rw [Integrable, HasFiniteIntegral, Memℒp, snorm_one_eq_lintegral_nnnorm]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
⊢ Memℒp f 1 μ ↔ Integrable f μ
state_after: no goals
Theorem: subset_sSup_of_within
File: Mathlib/Order/CompleteLatticeIntervals.lean

tactic: simp [dif_pos, h, h', h'']
state_before: ι : Sort u_1
α : Type u_2
s : Set α
inst✝² : Preorder α
inst✝¹ : SupSet α
inst✝ : Inhabited ↑s
t : Set ↑s
h' : t.Nonempty
h'' : BddAbove t
h : sSup (Subtype.val '' t) ∈ s
⊢ sSup (Subtype.val '' t) = ↑(sSup t)
state_after: no goals
Theorem: tprod_pi_single
File: Mathlib/Topology/Algebra/InfiniteSum/Constructions.lean

tactic: rw [tprod_eq_mulSingle b]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : TopologicalSpace α
inst✝ : DecidableEq β
b : β
a : α
⊢ ∏' (b' : β), Pi.mulSingle b a b' = a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : TopologicalSpace α
inst✝ : DecidableEq β
b : β
a : α
⊢ Pi.mulSingle b a b = a

α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : TopologicalSpace α
inst✝ : DecidableEq β
b : β
a : α
⊢ ∀ (b' : β), b' ≠ b → Pi.mulSingle b a b' = 1

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : TopologicalSpace α
inst✝ : DecidableEq β
b : β
a : α
⊢ Pi.mulSingle b a b = a
state_after: no goals

tactic: intro b' hb'
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : TopologicalSpace α
inst✝ : DecidableEq β
b : β
a : α
⊢ ∀ (b' : β), b' ≠ b → Pi.mulSingle b a b' = 1
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : TopologicalSpace α
inst✝ : DecidableEq β
b : β
a : α
b' : β
hb' : b' ≠ b
⊢ Pi.mulSingle b a b' = 1

tactic: simp [hb']
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : TopologicalSpace α
inst✝ : DecidableEq β
b : β
a : α
b' : β
hb' : b' ≠ b
⊢ Pi.mulSingle b a b' = 1
state_after: no goals
Theorem: Ordering.ite_eq_eq_distrib
File: Mathlib/Init/Data/Ordering/Lemmas.lean

tactic: by_cases c <;> simp [*]
state_before: c : Prop
inst✝ : Decidable c
a b : Ordering
⊢ ((if c then a else b) = eq) = if c then a = eq else b = eq
state_after: no goals
Theorem: Fin.val_add_eq_ite
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [Fin.val_add, Nat.add_mod_eq_ite, Nat.mod_eq_of_lt (show ↑a < n from a.2),
  Nat.mod_eq_of_lt (show ↑b < n from b.2)]
state_before: n✝ m n : ℕ
a b : Fin n
⊢ ↑(a + b) = if n ≤ ↑a + ↑b then ↑a + ↑b - n else ↑a + ↑b
state_after: no goals
Theorem: Behrend.roth_lower_bound
File: Mathlib/Combinatorics/Additive/AP/Three/Behrend.lean

tactic: obtain rfl | hN := Nat.eq_zero_or_pos N
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
⊢ ↑N * rexp (-4 * √(log ↑N)) ≤ ↑(rothNumberNat N)
state_after: case inl
α : Type u_1
β : Type u_2
n d k : ℕ
x : Fin n → ℕ
⊢ ↑0 * rexp (-4 * √(log ↑0)) ≤ ↑(rothNumberNat 0)

case inr
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : N > 0
⊢ ↑N * rexp (-4 * √(log ↑N)) ≤ ↑(rothNumberNat N)

tactic: obtain h₁ | h₁ := le_or_lt 4096 N
state_before: case inr
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : N > 0
⊢ ↑N * rexp (-4 * √(log ↑N)) ≤ ↑(rothNumberNat N)
state_after: case inr.inl
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : N > 0
h₁ : 4096 ≤ N
⊢ ↑N * rexp (-4 * √(log ↑N)) ≤ ↑(rothNumberNat N)

case inr.inr
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : N > 0
h₁ : N < 4096
⊢ ↑N * rexp (-4 * √(log ↑N)) ≤ ↑(rothNumberNat N)

tactic: norm_num
state_before: case inl
α : Type u_1
β : Type u_2
n d k : ℕ
x : Fin n → ℕ
⊢ ↑0 * rexp (-4 * √(log ↑0)) ≤ ↑(rothNumberNat 0)
state_after: no goals

tactic: exact (roth_lower_bound_explicit h₁).le
state_before: case inr.inl
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : N > 0
h₁ : 4096 ≤ N
⊢ ↑N * rexp (-4 * √(log ↑N)) ≤ ↑(rothNumberNat N)
state_after: no goals

tactic: apply (lower_bound_le_one hN h₁.le).trans
state_before: case inr.inr
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : N > 0
h₁ : N < 4096
⊢ ↑N * rexp (-4 * √(log ↑N)) ≤ ↑(rothNumberNat N)
state_after: case inr.inr
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : N > 0
h₁ : N < 4096
⊢ 1 ≤ ↑(rothNumberNat N)

tactic: simpa using rothNumberNat.monotone hN
state_before: case inr.inr
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : N > 0
h₁ : N < 4096
⊢ 1 ≤ ↑(rothNumberNat N)
state_after: no goals
Theorem: CochainComplex.mappingCone.decomp_to
File: Mathlib/Algebra/Homology/HomotopyCategory/MappingCone.lean

tactic: omega
state_before: C : Type u_1
inst✝² : Category.{?u.59165, u_1} C
inst✝¹ : Preadditive C
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
i : ℤ
A : C
f : A ⟶ (mappingCone φ).X i
j : ℤ
hij : i + 1 = j
a : A ⟶ F.X j
b : A ⟶ G.X i
⊢ j + -1 = i
state_after: no goals

tactic: apply ext_to φ i j hij <;> simp
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
i : ℤ
A : C
f : A ⟶ (mappingCone φ).X i
j : ℤ
hij : i + 1 = j
⊢ f = (f ≫ (↑(fst φ)).v i j hij) ≫ (inl φ).v j i ⋯ + (f ≫ (snd φ).v i i ⋯) ≫ (inr φ).f i
state_after: no goals
Theorem: Algebra.Presentation.aeval_val_relation
File: Mathlib/RingTheory/Presentation.lean

tactic: rw [← RingHom.mem_ker, ← P.ker_eq_ker_aeval_val, ← P.span_range_relation_eq_ker]
state_before: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
P : Presentation R S
i : P.rels
⊢ (aeval P.val) (P.relation i) = 0
state_after: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
P : Presentation R S
i : P.rels
⊢ P.relation i ∈ Ideal.span (Set.range P.relation)

tactic: exact Ideal.subset_span ⟨i, rfl⟩
state_before: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
P : Presentation R S
i : P.rels
⊢ P.relation i ∈ Ideal.span (Set.range P.relation)
state_after: no goals
Theorem: Subgroup.independent_of_coprime_order
File: Mathlib/GroupTheory/NoncommPiCoprod.lean

tactic: simpa using
  MonoidHom.independent_range_of_coprime_order (fun i => (H i).subtype)
    (commute_subtype_of_commute hcomm) hcoprime
state_before: G : Type u_1
inst✝² : Group G
ι : Type u_2
hdec : DecidableEq ι
hfin : Fintype ι
H : ι → Subgroup G
f g : (i : ι) → ↥(H i)
hcomm : Pairwise fun i j => ∀ (x y : G), x ∈ H i → y ∈ H j → Commute x y
inst✝¹ : Finite ι
inst✝ : (i : ι) → Fintype ↥(H i)
hcoprime : Pairwise fun i j => (Fintype.card ↥(H i)).Coprime (Fintype.card ↥(H j))
⊢ CompleteLattice.Independent H
state_after: no goals
Theorem: op_geom_sum
File: Mathlib/Algebra/GeomSum.lean

tactic: simp
state_before: α : Type u
inst✝ : Semiring α
x : α
n : ℕ
⊢ op (∑ i ∈ range n, x ^ i) = ∑ i ∈ range n, op x ^ i
state_after: no goals
Theorem: RingQuot.eq_liftAlgHom_comp_mkAlgHom
File: Mathlib/Algebra/RingQuot.lean

tactic: conv_lhs => rw [← (liftAlgHom S).apply_symm_apply f]
state_before: R : Type uR
inst✝⁶ : Semiring R
S : Type uS
inst✝⁵ : CommSemiring S
T : Type uT
A : Type uA
inst✝⁴ : Semiring A
inst✝³ : Algebra S A
r : R → R → Prop
inst✝² : Semiring T
B : Type u₄
inst✝¹ : Semiring B
inst✝ : Algebra S B
s : A → A → Prop
f : RingQuot s →ₐ[S] B
⊢ f = (liftAlgHom S) ⟨f.comp (mkAlgHom S s), ⋯⟩
state_after: R : Type uR
inst✝⁶ : Semiring R
S : Type uS
inst✝⁵ : CommSemiring S
T : Type uT
A : Type uA
inst✝⁴ : Semiring A
inst✝³ : Algebra S A
r : R → R → Prop
inst✝² : Semiring T
B : Type u₄
inst✝¹ : Semiring B
inst✝ : Algebra S B
s : A → A → Prop
f : RingQuot s →ₐ[S] B
⊢ (liftAlgHom S) ((liftAlgHom S).symm f) = (liftAlgHom S) ⟨f.comp (mkAlgHom S s), ⋯⟩

tactic: rw [liftAlgHom]
state_before: R : Type uR
inst✝⁶ : Semiring R
S : Type uS
inst✝⁵ : CommSemiring S
T : Type uT
A : Type uA
inst✝⁴ : Semiring A
inst✝³ : Algebra S A
r : R → R → Prop
inst✝² : Semiring T
B : Type u₄
inst✝¹ : Semiring B
inst✝ : Algebra S B
s : A → A → Prop
f : RingQuot s →ₐ[S] B
⊢ (liftAlgHom S) ((liftAlgHom S).symm f) = (liftAlgHom S) ⟨f.comp (mkAlgHom S s), ⋯⟩
state_after: R : Type uR
inst✝⁶ : Semiring R
S : Type uS
inst✝⁵ : CommSemiring S
T : Type uT
A : Type uA
inst✝⁴ : Semiring A
inst✝³ : Algebra S A
r : R → R → Prop
inst✝² : Semiring T
B : Type u₄
inst✝¹ : Semiring B
inst✝ : Algebra S B
s : A → A → Prop
f : RingQuot s →ₐ[S] B
⊢ { toFun := fun f' => preLiftAlgHom S ⋯, invFun := fun F => ⟨F.comp (mkAlgHom S s), ⋯⟩, left_inv := ⋯, right_inv := ⋯ }
      ({ toFun := fun f' => preLiftAlgHom S ⋯, invFun := fun F => ⟨F.comp (mkAlgHom S s), ⋯⟩, left_inv := ⋯,
            right_inv := ⋯ }.symm
        f) =
    { toFun := fun f' => preLiftAlgHom S ⋯, invFun := fun F => ⟨F.comp (mkAlgHom S s), ⋯⟩, left_inv := ⋯,
        right_inv := ⋯ }
      ⟨f.comp (mkAlgHom S s), ⋯⟩

tactic: rfl
state_before: R : Type uR
inst✝⁶ : Semiring R
S : Type uS
inst✝⁵ : CommSemiring S
T : Type uT
A : Type uA
inst✝⁴ : Semiring A
inst✝³ : Algebra S A
r : R → R → Prop
inst✝² : Semiring T
B : Type u₄
inst✝¹ : Semiring B
inst✝ : Algebra S B
s : A → A → Prop
f : RingQuot s →ₐ[S] B
⊢ { toFun := fun f' => preLiftAlgHom S ⋯, invFun := fun F => ⟨F.comp (mkAlgHom S s), ⋯⟩, left_inv := ⋯, right_inv := ⋯ }
      ({ toFun := fun f' => preLiftAlgHom S ⋯, invFun := fun F => ⟨F.comp (mkAlgHom S s), ⋯⟩, left_inv := ⋯,
            right_inv := ⋯ }.symm
        f) =
    { toFun := fun f' => preLiftAlgHom S ⋯, invFun := fun F => ⟨F.comp (mkAlgHom S s), ⋯⟩, left_inv := ⋯,
        right_inv := ⋯ }
      ⟨f.comp (mkAlgHom S s), ⋯⟩
state_after: no goals
Theorem: Real.sin_zero
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [sin]
state_before: x y : ℝ
⊢ sin 0 = 0
state_after: no goals
Theorem: List.Ico.filter_le
File: Mathlib/Data/List/Intervals.lean

tactic: rcases le_total n l with hnl | hln
state_before: n m l : ℕ
⊢ filter (fun x => decide (l ≤ x)) (Ico n m) = Ico (max n l) m
state_after: case inl
n m l : ℕ
hnl : n ≤ l
⊢ filter (fun x => decide (l ≤ x)) (Ico n m) = Ico (max n l) m

case inr
n m l : ℕ
hln : l ≤ n
⊢ filter (fun x => decide (l ≤ x)) (Ico n m) = Ico (max n l) m

tactic: rw [max_eq_right hnl, filter_le_of_le hnl]
state_before: case inl
n m l : ℕ
hnl : n ≤ l
⊢ filter (fun x => decide (l ≤ x)) (Ico n m) = Ico (max n l) m
state_after: no goals

tactic: rw [max_eq_left hln, filter_le_of_le_bot hln]
state_before: case inr
n m l : ℕ
hln : l ≤ n
⊢ filter (fun x => decide (l ≤ x)) (Ico n m) = Ico (max n l) m
state_after: no goals
Theorem: neg_pow_bit0
File: Mathlib/Algebra/Ring/Commute.lean

tactic: rw [pow_bit0', neg_mul_neg, pow_bit0']
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝¹ : Monoid R
inst✝ : HasDistribNeg R
a : R
n : ℕ
⊢ (-a) ^ bit0 n = a ^ bit0 n
state_after: no goals
Theorem: MeasureTheory.LocallyIntegrable.integrable_of_isBigO_cocompact
File: Mathlib/MeasureTheory/Integral/Asymptotics.lean

tactic: refine integrable_iff_integrableAtFilter_cocompact.mpr ⟨ho.integrableAtFilter ?_ hg, hf⟩
state_before: α : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : MeasurableSpace α
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
f : α → E
g : α → F
a b : α
μ : Measure α
l : Filter α
inst✝² : TopologicalSpace α
inst✝¹ : SecondCountableTopology α
inst✝ : (cocompact α).IsMeasurablyGenerated
hf : LocallyIntegrable f μ
ho : f =O[cocompact α] g
hg : IntegrableAtFilter g (cocompact α) μ
⊢ Integrable f μ
state_after: α : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : MeasurableSpace α
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
f : α → E
g : α → F
a b : α
μ : Measure α
l : Filter α
inst✝² : TopologicalSpace α
inst✝¹ : SecondCountableTopology α
inst✝ : (cocompact α).IsMeasurablyGenerated
hf : LocallyIntegrable f μ
ho : f =O[cocompact α] g
hg : IntegrableAtFilter g (cocompact α) μ
⊢ StronglyMeasurableAtFilter f (cocompact α) μ

tactic: exact hf.aestronglyMeasurable.stronglyMeasurableAtFilter
state_before: α : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : MeasurableSpace α
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
f : α → E
g : α → F
a b : α
μ : Measure α
l : Filter α
inst✝² : TopologicalSpace α
inst✝¹ : SecondCountableTopology α
inst✝ : (cocompact α).IsMeasurablyGenerated
hf : LocallyIntegrable f μ
ho : f =O[cocompact α] g
hg : IntegrableAtFilter g (cocompact α) μ
⊢ StronglyMeasurableAtFilter f (cocompact α) μ
state_after: no goals
Theorem: Filter.EventuallyEq.of_eventually_mem_of_forall_separating_mem_iff
File: Mathlib/Order/Filter/CountableSeparatingOn.lean

tactic: rcases h'.1 with ⟨S, hSc, hSp, hS⟩
state_before: α : Type u_1
β : Type u_2
l : Filter α
inst✝ : CountableInterFilter l
f g : α → β
p : Set β → Prop
s : Set β
h' : HasCountableSeparatingOn β p s
hf : ∀ᶠ (x : α) in l, f x ∈ s
hg : ∀ᶠ (x : α) in l, g x ∈ s
h : ∀ (U : Set β), p U → ∀ᶠ (x : α) in l, f x ∈ U ↔ g x ∈ U
⊢ f =ᶠ[l] g
state_after: case intro.intro.intro
α : Type u_1
β : Type u_2
l : Filter α
inst✝ : CountableInterFilter l
f g : α → β
p : Set β → Prop
s : Set β
h' : HasCountableSeparatingOn β p s
hf : ∀ᶠ (x : α) in l, f x ∈ s
hg : ∀ᶠ (x : α) in l, g x ∈ s
h : ∀ (U : Set β), p U → ∀ᶠ (x : α) in l, f x ∈ U ↔ g x ∈ U
S : Set (Set β)
hSc : S.Countable
hSp : ∀ s ∈ S, p s
hS : ∀ x ∈ s, ∀ y ∈ s, (∀ s ∈ S, x ∈ s ↔ y ∈ s) → x = y
⊢ f =ᶠ[l] g

tactic: have H : ∀ᶠ x in l, ∀ s ∈ S, f x ∈ s ↔ g x ∈ s :=
  (eventually_countable_ball hSc).2 fun s hs ↦ (h _ (hSp _ hs))
state_before: case intro.intro.intro
α : Type u_1
β : Type u_2
l : Filter α
inst✝ : CountableInterFilter l
f g : α → β
p : Set β → Prop
s : Set β
h' : HasCountableSeparatingOn β p s
hf : ∀ᶠ (x : α) in l, f x ∈ s
hg : ∀ᶠ (x : α) in l, g x ∈ s
h : ∀ (U : Set β), p U → ∀ᶠ (x : α) in l, f x ∈ U ↔ g x ∈ U
S : Set (Set β)
hSc : S.Countable
hSp : ∀ s ∈ S, p s
hS : ∀ x ∈ s, ∀ y ∈ s, (∀ s ∈ S, x ∈ s ↔ y ∈ s) → x = y
⊢ f =ᶠ[l] g
state_after: case intro.intro.intro
α : Type u_1
β : Type u_2
l : Filter α
inst✝ : CountableInterFilter l
f g : α → β
p : Set β → Prop
s : Set β
h' : HasCountableSeparatingOn β p s
hf : ∀ᶠ (x : α) in l, f x ∈ s
hg : ∀ᶠ (x : α) in l, g x ∈ s
h : ∀ (U : Set β), p U → ∀ᶠ (x : α) in l, f x ∈ U ↔ g x ∈ U
S : Set (Set β)
hSc : S.Countable
hSp : ∀ s ∈ S, p s
hS : ∀ x ∈ s, ∀ y ∈ s, (∀ s ∈ S, x ∈ s ↔ y ∈ s) → x = y
H : ∀ᶠ (x : α) in l, ∀ s ∈ S, f x ∈ s ↔ g x ∈ s
⊢ f =ᶠ[l] g

tactic: filter_upwards [H, hf, hg] with x hx hxf hxg using hS _ hxf _ hxg hx
state_before: case intro.intro.intro
α : Type u_1
β : Type u_2
l : Filter α
inst✝ : CountableInterFilter l
f g : α → β
p : Set β → Prop
s : Set β
h' : HasCountableSeparatingOn β p s
hf : ∀ᶠ (x : α) in l, f x ∈ s
hg : ∀ᶠ (x : α) in l, g x ∈ s
h : ∀ (U : Set β), p U → ∀ᶠ (x : α) in l, f x ∈ U ↔ g x ∈ U
S : Set (Set β)
hSc : S.Countable
hSp : ∀ s ∈ S, p s
hS : ∀ x ∈ s, ∀ y ∈ s, (∀ s ∈ S, x ∈ s ↔ y ∈ s) → x = y
H : ∀ᶠ (x : α) in l, ∀ s ∈ S, f x ∈ s ↔ g x ∈ s
⊢ f =ᶠ[l] g
state_after: no goals
Theorem: Nat.Ico_succ_left_eq_erase_Ico
File: Mathlib/Order/Interval/Finset/Nat.lean

tactic: ext x
state_before: a b c : ℕ
⊢ Ico a.succ b = (Ico a b).erase a
state_after: case a
a b c x : ℕ
⊢ x ∈ Ico a.succ b ↔ x ∈ (Ico a b).erase a

tactic: rw [Ico_succ_left, mem_erase, mem_Ico, mem_Ioo, ← and_assoc, ne_comm, @and_comm (a ≠ x),
  lt_iff_le_and_ne]
state_before: case a
a b c x : ℕ
⊢ x ∈ Ico a.succ b ↔ x ∈ (Ico a b).erase a
state_after: no goals
Theorem: SimpleGraph.isAdjMatrix_adjMatrix
File: Mathlib/Combinatorics/SimpleGraph/AdjMatrix.lean

tactic: by_cases h : G.Adj i j <;> simp [h]
state_before: V : Type u_1
α : Type u_2
β : Type u_3
G : SimpleGraph V
inst✝² : DecidableRel G.Adj
inst✝¹ : Zero α
inst✝ : One α
i j : V
⊢ adjMatrix α G i j = 0 ∨ adjMatrix α G i j = 1
state_after: no goals
Theorem: Ideal.quotientMap_surjective
File: Mathlib/RingTheory/Ideal/QuotientOperations.lean

tactic: simp [hx, hy]
state_before: R : Type u
S✝ : Type v
F : Type w
inst✝⁷ : CommRing R
inst✝⁶ : Semiring S✝
R₁ : Type u_1
R₂ : Type u_2
A : Type u_3
B : Type u_4
inst✝⁵ : CommSemiring R₁
inst✝⁴ : CommSemiring R₂
inst✝³ : CommRing A
inst✝² : Algebra R₁ A
inst✝¹ : Algebra R₂ A
S : Type v
inst✝ : CommRing S
J : Ideal R
I : Ideal S
f : R →+* S
H : J ≤ comap f I
hf : Surjective ⇑f
x✝ : S ⧸ I
x : S
hx : (Quotient.mk I) x = x✝
y : R
hy : f y = x
⊢ (quotientMap I f H) ((Quotient.mk J) y) = x✝
state_after: no goals
Theorem: MulOneClass.ext
File: Mathlib/Algebra/Group/Defs.lean

tactic: rintro @⟨⟨one₁⟩, ⟨mul₁⟩, one_mul₁, mul_one₁⟩ @⟨⟨one₂⟩, ⟨mul₂⟩, one_mul₂, mul_one₂⟩ ⟨rfl⟩
state_before: G : Type u_1
M : Type u
⊢ ∀ ⦃m₁ m₂ : MulOneClass M⦄, Mul.mul = Mul.mul → m₁ = m₂
state_after: case mk.mk.mk.mk.mk.mk.refl
G : Type u_1
M : Type u
one₁ : M
mul₁ : M → M → M
one_mul₁ : ∀ (a : M), 1 * a = a
mul_one₁ : ∀ (a : M), a * 1 = a
one₂ : M
one_mul₂ : ∀ (a : M), 1 * a = a
mul_one₂ : ∀ (a : M), a * 1 = a
⊢ mk one_mul₁ mul_one₁ = mk one_mul₂ mul_one₂

tactic: suffices one₁ = one₂ by cases this; rfl
state_before: case mk.mk.mk.mk.mk.mk.refl
G : Type u_1
M : Type u
one₁ : M
mul₁ : M → M → M
one_mul₁ : ∀ (a : M), 1 * a = a
mul_one₁ : ∀ (a : M), a * 1 = a
one₂ : M
one_mul₂ : ∀ (a : M), 1 * a = a
mul_one₂ : ∀ (a : M), a * 1 = a
⊢ mk one_mul₁ mul_one₁ = mk one_mul₂ mul_one₂
state_after: case mk.mk.mk.mk.mk.mk.refl
G : Type u_1
M : Type u
one₁ : M
mul₁ : M → M → M
one_mul₁ : ∀ (a : M), 1 * a = a
mul_one₁ : ∀ (a : M), a * 1 = a
one₂ : M
one_mul₂ : ∀ (a : M), 1 * a = a
mul_one₂ : ∀ (a : M), a * 1 = a
⊢ one₁ = one₂

tactic: exact (one_mul₂ one₁).symm.trans (mul_one₁ one₂)
state_before: case mk.mk.mk.mk.mk.mk.refl
G : Type u_1
M : Type u
one₁ : M
mul₁ : M → M → M
one_mul₁ : ∀ (a : M), 1 * a = a
mul_one₁ : ∀ (a : M), a * 1 = a
one₂ : M
one_mul₂ : ∀ (a : M), 1 * a = a
mul_one₂ : ∀ (a : M), a * 1 = a
⊢ one₁ = one₂
state_after: no goals

tactic: cases this
state_before: G : Type u_1
M : Type u
one₁ : M
mul₁ : M → M → M
one_mul₁ : ∀ (a : M), 1 * a = a
mul_one₁ : ∀ (a : M), a * 1 = a
one₂ : M
one_mul₂ : ∀ (a : M), 1 * a = a
mul_one₂ : ∀ (a : M), a * 1 = a
this : one₁ = one₂
⊢ mk one_mul₁ mul_one₁ = mk one_mul₂ mul_one₂
state_after: case refl
G : Type u_1
M : Type u
one₁ : M
mul₁ : M → M → M
one_mul₁ : ∀ (a : M), 1 * a = a
mul_one₁ : ∀ (a : M), a * 1 = a
one_mul₂ : ∀ (a : M), 1 * a = a
mul_one₂ : ∀ (a : M), a * 1 = a
⊢ mk one_mul₁ mul_one₁ = mk one_mul₂ mul_one₂

tactic: rfl
state_before: case refl
G : Type u_1
M : Type u
one₁ : M
mul₁ : M → M → M
one_mul₁ : ∀ (a : M), 1 * a = a
mul_one₁ : ∀ (a : M), a * 1 = a
one_mul₂ : ∀ (a : M), 1 * a = a
mul_one₂ : ∀ (a : M), a * 1 = a
⊢ mk one_mul₁ mul_one₁ = mk one_mul₂ mul_one₂
state_after: no goals
Theorem: ENNReal.div_eq_one_iff
File: Mathlib/Data/ENNReal/Inv.lean

tactic: rw [← (eq_div_iff hb₀ hb₁).mp h.symm, mul_one]
state_before: a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a b : ℝ≥0∞
hb₀ : b ≠ 0
hb₁ : b ≠ ⊤
h : a / b = 1
⊢ a = b
state_after: no goals
Theorem: Ordinal.one_toPGame_moveLeft
File: Mathlib/SetTheory/Game/Ordinal.lean

tactic: simp
state_before: x : (toPGame 1).LeftMoves
⊢ (toPGame 1).moveLeft x = toPGame 0
state_after: no goals
Theorem: Finset.Ico_union_Ico
File: Mathlib/Order/Interval/Finset/Basic.lean

tactic: rw [← coe_inj, coe_union, coe_Ico, coe_Ico, coe_Ico, Set.Ico_union_Ico h₁ h₂]
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ a b c d : α
h₁ : min a b ≤ max c d
h₂ : min c d ≤ max a b
⊢ Ico a b ∪ Ico c d = Ico (min a c) (max b d)
state_after: no goals
Theorem: MvPolynomial.totalDegree_eq
File: Mathlib/Algebra/MvPolynomial/Degrees.lean

tactic: rw [totalDegree]
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 p : MvPolynomial σ R
⊢ p.totalDegree = p.support.sup fun m => Multiset.card (toMultiset m)
state_after: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p✝ q p : MvPolynomial σ R
⊢ (p.support.sup fun s => s.sum fun x e => e) = p.support.sup fun m => Multiset.card (toMultiset m)

tactic: congr
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 p : MvPolynomial σ R
⊢ (p.support.sup fun s => s.sum fun x e => e) = p.support.sup fun m => Multiset.card (toMultiset m)
state_after: case e_f
R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p✝ q p : MvPolynomial σ R
⊢ (fun s => s.sum fun x e => e) = fun m => Multiset.card (toMultiset m)

tactic: funext m
state_before: case e_f
R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p✝ q p : MvPolynomial σ R
⊢ (fun s => s.sum fun x e => e) = fun m => Multiset.card (toMultiset m)
state_after: case e_f.h
R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m✝ : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p✝ q p : MvPolynomial σ R
m : σ →₀ ℕ
⊢ (m.sum fun x e => e) = Multiset.card (toMultiset m)

tactic: exact (Finsupp.card_toMultiset _).symm
state_before: case e_f.h
R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m✝ : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p✝ q p : MvPolynomial σ R
m : σ →₀ ℕ
⊢ (m.sum fun x e => e) = Multiset.card (toMultiset m)
state_after: no goals
Theorem: List.get?_modifyNth_eq
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: simp [getElem?_modifyNth_eq]
state_before: α : Type u_1
f : α → α
n : Nat
l : List α
⊢ (modifyNth f n l).get? n = f <$> l.get? n
state_after: no goals