1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Matroid.mapEquiv_base_iff
File: Mathlib/Data/Matroid/Map.lean

tactic: rw [mapEquiv_eq_map, map_base_iff]
state_before: α : Type u_1
β : Type u_2
f✝ : α → β
E I s : Set α
M : Matroid α
N : Matroid β
f : α ≃ β
B : Set β
⊢ (M.mapEquiv f).Base B ↔ M.Base (⇑f.symm '' B)
state_after: α : Type u_1
β : Type u_2
f✝ : α → β
E I s : Set α
M : Matroid α
N : Matroid β
f : α ≃ β
B : Set β
⊢ (∃ B₀, M.Base B₀ ∧ B = ⇑f '' B₀) ↔ M.Base (⇑f.symm '' B)

tactic: exact ⟨by rintro ⟨I, hI, rfl⟩; simpa, fun h ↦ ⟨_, h, by simp⟩⟩
state_before: α : Type u_1
β : Type u_2
f✝ : α → β
E I s : Set α
M : Matroid α
N : Matroid β
f : α ≃ β
B : Set β
⊢ (∃ B₀, M.Base B₀ ∧ B = ⇑f '' B₀) ↔ M.Base (⇑f.symm '' B)
state_after: no goals

tactic: rintro ⟨I, hI, rfl⟩
state_before: α : Type u_1
β : Type u_2
f✝ : α → β
E I s : Set α
M : Matroid α
N : Matroid β
f : α ≃ β
B : Set β
⊢ (∃ B₀, M.Base B₀ ∧ B = ⇑f '' B₀) → M.Base (⇑f.symm '' B)
state_after: case intro.intro
α : Type u_1
β : Type u_2
f✝ : α → β
E I✝ s : Set α
M : Matroid α
N : Matroid β
f : α ≃ β
I : Set α
hI : M.Base I
⊢ M.Base (⇑f.symm '' (⇑f '' I))

tactic: simpa
state_before: case intro.intro
α : Type u_1
β : Type u_2
f✝ : α → β
E I✝ s : Set α
M : Matroid α
N : Matroid β
f : α ≃ β
I : Set α
hI : M.Base I
⊢ M.Base (⇑f.symm '' (⇑f '' I))
state_after: no goals

tactic: simp
state_before: α : Type u_1
β : Type u_2
f✝ : α → β
E I s : Set α
M : Matroid α
N : Matroid β
f : α ≃ β
B : Set β
h : M.Base (⇑f.symm '' B)
⊢ B = ⇑f '' (⇑f.symm '' B)
state_after: no goals
Theorem: SzemerediRegularity.m_pos
File: Mathlib/Combinatorics/SimpleGraph/Regularity/Bound.lean

tactic: sz_positivity
state_before: α : Type u_1
inst✝² : DecidableEq α
inst✝¹ : Fintype α
P : Finpartition univ
u : Finset α
ε : ℝ
inst✝ : Nonempty α
hPα : P.parts.card * 16 ^ P.parts.card ≤ Fintype.card α
⊢ 0 < m
state_after: no goals
Theorem: Matrix.det_one
File: Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean

tactic: rw [← diagonal_one]
state_before: m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
⊢ det 1 = 1
state_after: m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
⊢ (diagonal fun x => 1).det = 1

tactic: simp [-diagonal_one]
state_before: m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
⊢ (diagonal fun x => 1).det = 1
state_after: no goals
Theorem: Nat.modEq_three_digits_sum
File: Mathlib/Data/Nat/Digits.lean

tactic: norm_num
state_before: n✝ n : ℕ
⊢ 10 % 3 = 1
state_after: no goals
Theorem: TopCat.Presheaf.pushforwardEq_rfl
File: Mathlib/Topology/Sheaves/Presheaf.lean

tactic: dsimp [pushforwardEq]
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
f : X ⟶ Y
ℱ : Presheaf C X
U : Opens ↑Y
⊢ (pushforwardEq ⋯ ℱ).hom.app { unop := U } = 𝟙 ((f _* ℱ).obj { unop := U })
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
f : X ⟶ Y
ℱ : Presheaf C X
U : Opens ↑Y
⊢ ℱ.map (𝟙 { unop := (Opens.map f).obj U }) = 𝟙 (ℱ.obj { unop := (Opens.map f).obj U })

tactic: simp
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
f : X ⟶ Y
ℱ : Presheaf C X
U : Opens ↑Y
⊢ ℱ.map (𝟙 { unop := (Opens.map f).obj U }) = 𝟙 (ℱ.obj { unop := (Opens.map f).obj U })
state_after: no goals
Theorem: Polynomial.monomial_pow
File: Mathlib/Algebra/Polynomial/Basic.lean

tactic: induction' k with k ih
state_before: R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
r : R
k : ℕ
⊢ (monomial n) r ^ k = (monomial (n * k)) (r ^ k)
state_after: case zero
R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
r : R
⊢ (monomial n) r ^ 0 = (monomial (n * 0)) (r ^ 0)

case succ
R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
r : R
k : ℕ
ih : (monomial n) r ^ k = (monomial (n * k)) (r ^ k)
⊢ (monomial n) r ^ (k + 1) = (monomial (n * (k + 1))) (r ^ (k + 1))

tactic: simp [pow_zero, monomial_zero_one]
state_before: case zero
R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
r : R
⊢ (monomial n) r ^ 0 = (monomial (n * 0)) (r ^ 0)
state_after: no goals

tactic: simp [pow_succ, ih, monomial_mul_monomial, mul_add, add_comm]
state_before: case succ
R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
r : R
k : ℕ
ih : (monomial n) r ^ k = (monomial (n * k)) (r ^ k)
⊢ (monomial n) r ^ (k + 1) = (monomial (n * (k + 1))) (r ^ (k + 1))
state_after: no goals
Theorem: Polynomial.coeff_natTrailingDegree_eq_zero
File: Mathlib/Algebra/Polynomial/Degree/TrailingDegree.lean

tactic: constructor
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
⊢ p.coeff p.natTrailingDegree = 0 ↔ p = 0
state_after: case mp
R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
⊢ p.coeff p.natTrailingDegree = 0 → p = 0

case mpr
R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
⊢ p = 0 → p.coeff p.natTrailingDegree = 0

tactic: rintro h
state_before: case mp
R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
⊢ p.coeff p.natTrailingDegree = 0 → p = 0
state_after: case mp
R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : p.coeff p.natTrailingDegree = 0
⊢ p = 0

tactic: by_contra hp
state_before: case mp
R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : p.coeff p.natTrailingDegree = 0
⊢ p = 0
state_after: case mp
R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : p.coeff p.natTrailingDegree = 0
hp : ¬p = 0
⊢ False

tactic: obtain ⟨n, hpn, hn⟩ := by simpa using min_mem_image_coe $ support_nonempty.2 hp
state_before: case mp
R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : p.coeff p.natTrailingDegree = 0
hp : ¬p = 0
⊢ False
state_after: case mp.intro.intro
R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : p.coeff p.natTrailingDegree = 0
hp : ¬p = 0
n : ℕ
hpn : ¬p.coeff n = 0
hn : ↑n = p.support.min
⊢ False

tactic: obtain rfl := (trailingDegree_eq_iff_natTrailingDegree_eq hp).1 hn.symm
state_before: case mp.intro.intro
R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : p.coeff p.natTrailingDegree = 0
hp : ¬p = 0
n : ℕ
hpn : ¬p.coeff n = 0
hn : ↑n = p.support.min
⊢ False
state_after: case mp.intro.intro
R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : p.coeff p.natTrailingDegree = 0
hp : ¬p = 0
hpn : ¬p.coeff p.natTrailingDegree = 0
hn : ↑p.natTrailingDegree = p.support.min
⊢ False

tactic: exact hpn h
state_before: case mp.intro.intro
R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : p.coeff p.natTrailingDegree = 0
hp : ¬p = 0
hpn : ¬p.coeff p.natTrailingDegree = 0
hn : ↑p.natTrailingDegree = p.support.min
⊢ False
state_after: no goals

tactic: simpa using min_mem_image_coe $ support_nonempty.2 hp
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : p.coeff p.natTrailingDegree = 0
hp : ¬p = 0
⊢ ?m.5837
state_after: no goals

tactic: rintro rfl
state_before: case mpr
R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
⊢ p = 0 → p.coeff p.natTrailingDegree = 0
state_after: case mpr
R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
q r : R[X]
⊢ coeff 0 (natTrailingDegree 0) = 0

tactic: simp
state_before: case mpr
R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
q r : R[X]
⊢ coeff 0 (natTrailingDegree 0) = 0
state_after: no goals
Theorem: MeasureTheory.Measure.restrict_apply₀
File: Mathlib/MeasureTheory/Measure/Restrict.lean

tactic: rw [← restrictₗ_apply, restrictₗ, liftLinear_apply₀ _ ht, OuterMeasure.restrict_apply,
  coe_toOuterMeasure]
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 α
ht : NullMeasurableSet t (μ.restrict s)
⊢ (μ.restrict s) t = μ (t ∩ s)
state_after: no goals
Theorem: memPartitionSet_eq_iff
File: Mathlib/Data/Set/MemPartition.lean

tactic: refine ⟨fun h ↦ h ▸ mem_memPartitionSet f n a, fun h ↦ ?_⟩
state_before: α : Type u_1
f : ℕ → Set α
n : ℕ
a : α
s : Set α
hs : s ∈ memPartition f n
⊢ memPartitionSet f n a = s ↔ a ∈ s
state_after: α : Type u_1
f : ℕ → Set α
n : ℕ
a : α
s : Set α
hs : s ∈ memPartition f n
h : a ∈ s
⊢ memPartitionSet f n a = s

tactic: by_contra h_ne
state_before: α : Type u_1
f : ℕ → Set α
n : ℕ
a : α
s : Set α
hs : s ∈ memPartition f n
h : a ∈ s
⊢ memPartitionSet f n a = s
state_after: α : Type u_1
f : ℕ → Set α
n : ℕ
a : α
s : Set α
hs : s ∈ memPartition f n
h : a ∈ s
h_ne : ¬memPartitionSet f n a = s
⊢ False

tactic: have h_disj : Disjoint s (memPartitionSet f n a) :=
  disjoint_memPartition f n hs (memPartitionSet_mem f n a) (Ne.symm h_ne)
state_before: α : Type u_1
f : ℕ → Set α
n : ℕ
a : α
s : Set α
hs : s ∈ memPartition f n
h : a ∈ s
h_ne : ¬memPartitionSet f n a = s
⊢ False
state_after: α : Type u_1
f : ℕ → Set α
n : ℕ
a : α
s : Set α
hs : s ∈ memPartition f n
h : a ∈ s
h_ne : ¬memPartitionSet f n a = s
h_disj : Disjoint s (memPartitionSet f n a)
⊢ False

tactic: refine absurd h_disj ?_
state_before: α : Type u_1
f : ℕ → Set α
n : ℕ
a : α
s : Set α
hs : s ∈ memPartition f n
h : a ∈ s
h_ne : ¬memPartitionSet f n a = s
h_disj : Disjoint s (memPartitionSet f n a)
⊢ False
state_after: α : Type u_1
f : ℕ → Set α
n : ℕ
a : α
s : Set α
hs : s ∈ memPartition f n
h : a ∈ s
h_ne : ¬memPartitionSet f n a = s
h_disj : Disjoint s (memPartitionSet f n a)
⊢ ¬Disjoint s (memPartitionSet f n a)

tactic: rw [not_disjoint_iff_nonempty_inter]
state_before: α : Type u_1
f : ℕ → Set α
n : ℕ
a : α
s : Set α
hs : s ∈ memPartition f n
h : a ∈ s
h_ne : ¬memPartitionSet f n a = s
h_disj : Disjoint s (memPartitionSet f n a)
⊢ ¬Disjoint s (memPartitionSet f n a)
state_after: α : Type u_1
f : ℕ → Set α
n : ℕ
a : α
s : Set α
hs : s ∈ memPartition f n
h : a ∈ s
h_ne : ¬memPartitionSet f n a = s
h_disj : Disjoint s (memPartitionSet f n a)
⊢ (s ∩ memPartitionSet f n a).Nonempty

tactic: exact ⟨a, h, mem_memPartitionSet f n a⟩
state_before: α : Type u_1
f : ℕ → Set α
n : ℕ
a : α
s : Set α
hs : s ∈ memPartition f n
h : a ∈ s
h_ne : ¬memPartitionSet f n a = s
h_disj : Disjoint s (memPartitionSet f n a)
⊢ (s ∩ memPartitionSet f n a).Nonempty
state_after: no goals
Theorem: mul_cancel_right_mem_nonZeroDivisors
File: Mathlib/Algebra/GroupWithZero/NonZeroDivisors.lean

tactic: rw [← sub_eq_zero, ← mul_right_mem_nonZeroDivisors_eq_zero_iff hr, sub_mul, h, sub_self]
state_before: M₀ : Type u_1
inst✝⁵ : MonoidWithZero M₀
M : Type u_2
M' : Type u_3
M₁ : Type u_4
R : Type u_5
R' : Type u_6
F : Type u_7
inst✝⁴ : MonoidWithZero M
inst✝³ : MonoidWithZero M'
inst✝² : CommMonoidWithZero M₁
inst✝¹ : Ring R
inst✝ : CommRing R'
x y r : R
hr : r ∈ R⁰
h : x * r = y * r
⊢ x = y
state_after: no goals
Theorem: SimpleGraph.map_adj_apply
File: Mathlib/Combinatorics/SimpleGraph/Maps.lean

tactic: simp
state_before: V : Type u_1
W : Type u_2
X : Type u_3
G✝ : SimpleGraph V
G' : SimpleGraph W
u v : V
G : SimpleGraph V
f : V ↪ W
a b : V
⊢ (SimpleGraph.map f G).Adj (f a) (f b) ↔ G.Adj a b
state_after: no goals
Theorem: sub_one_mul_padicValNat_choose_eq_sub_sum_digits'
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: have h : k ≤ n + k := by exact Nat.le_add_left k n
state_before: p k n : ℕ
hp : Fact (Nat.Prime p)
⊢ (p - 1) * padicValNat p ((n + k).choose k) = (p.digits k).sum + (p.digits n).sum - (p.digits (n + k)).sum
state_after: p k n : ℕ
hp : Fact (Nat.Prime p)
h : k ≤ n + k
⊢ (p - 1) * padicValNat p ((n + k).choose k) = (p.digits k).sum + (p.digits n).sum - (p.digits (n + k)).sum

tactic: simp only [Nat.choose_eq_factorial_div_factorial h]
state_before: p k n : ℕ
hp : Fact (Nat.Prime p)
h : k ≤ n + k
⊢ (p - 1) * padicValNat p ((n + k).choose k) = (p.digits k).sum + (p.digits n).sum - (p.digits (n + k)).sum
state_after: p k n : ℕ
hp : Fact (Nat.Prime p)
h : k ≤ n + k
⊢ (p - 1) * padicValNat p ((n + k)! / (k ! * (n + k - k)!)) =
    (p.digits k).sum + (p.digits n).sum - (p.digits (n + k)).sum

tactic: rw [padicValNat.div_of_dvd <| factorial_mul_factorial_dvd_factorial h, Nat.mul_sub_left_distrib,
    padicValNat.mul (factorial_ne_zero _) (factorial_ne_zero _), Nat.mul_add]
state_before: p k n : ℕ
hp : Fact (Nat.Prime p)
h : k ≤ n + k
⊢ (p - 1) * padicValNat p ((n + k)! / (k ! * (n + k - k)!)) =
    (p.digits k).sum + (p.digits n).sum - (p.digits (n + k)).sum
state_after: p k n : ℕ
hp : Fact (Nat.Prime p)
h : k ≤ n + k
⊢ (p - 1) * padicValNat p (n + k)! - ((p - 1) * padicValNat p k ! + (p - 1) * padicValNat p (n + k - k)!) =
    (p.digits k).sum + (p.digits n).sum - (p.digits (n + k)).sum

tactic: simp only [sub_one_mul_padicValNat_factorial]
state_before: p k n : ℕ
hp : Fact (Nat.Prime p)
h : k ≤ n + k
⊢ (p - 1) * padicValNat p (n + k)! - ((p - 1) * padicValNat p k ! + (p - 1) * padicValNat p (n + k - k)!) =
    (p.digits k).sum + (p.digits n).sum - (p.digits (n + k)).sum
state_after: p k n : ℕ
hp : Fact (Nat.Prime p)
h : k ≤ n + k
⊢ n + k - (p.digits (n + k)).sum - (k - (p.digits k).sum + (n + k - k - (p.digits (n + k - k)).sum)) =
    (p.digits k).sum + (p.digits n).sum - (p.digits (n + k)).sum

tactic: rw [← Nat.sub_add_comm <| digit_sum_le p k, Nat.add_sub_cancel n k, ← Nat.add_sub_assoc <|
    digit_sum_le p n, Nat.sub_sub (k + n), ← Nat.sub_right_comm, Nat.sub_sub, sub_add_eq,
    add_comm, tsub_tsub_assoc (Nat.le_refl (k + n)) <| (add_comm k n) ▸ (Nat.add_le_add
    (digit_sum_le p n) (digit_sum_le p k)), Nat.sub_self (k + n), zero_add, add_comm]
state_before: p k n : ℕ
hp : Fact (Nat.Prime p)
h : k ≤ n + k
⊢ n + k - (p.digits (n + k)).sum - (k - (p.digits k).sum + (n + k - k - (p.digits (n + k - k)).sum)) =
    (p.digits k).sum + (p.digits n).sum - (p.digits (n + k)).sum
state_after: no goals

tactic: exact Nat.le_add_left k n
state_before: p k n : ℕ
hp : Fact (Nat.Prime p)
⊢ k ≤ n + k
state_after: no goals
Theorem: NormedAddGroupHom.le_of_opNorm_le
File: Mathlib/Analysis/Normed/Group/Hom.lean

tactic: gcongr
state_before: V : Type u_1
V₁ : Type u_2
V₂ : Type u_3
V₃ : Type u_4
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f g : NormedAddGroupHom V₁ V₂
c : ℝ
h : ‖f‖ ≤ c
x : V₁
⊢ ‖f‖ * ‖x‖ ≤ c * ‖x‖
state_after: no goals
Theorem: MeasureTheory.Content.contentRegular_exists_compact
File: Mathlib/MeasureTheory/Measure/Content.lean

tactic: by_contra hc
state_before: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
H : μ.ContentRegular
K : Compacts G
ε : ℝ≥0
hε : ε ≠ 0
⊢ ∃ K', K.carrier ⊆ interior K'.carrier ∧ (fun s => ↑(μ.toFun s)) K' ≤ (fun s => ↑(μ.toFun s)) K + ↑ε
state_after: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
H : μ.ContentRegular
K : Compacts G
ε : ℝ≥0
hε : ε ≠ 0
hc : ¬∃ K', K.carrier ⊆ interior K'.carrier ∧ (fun s => ↑(μ.toFun s)) K' ≤ (fun s => ↑(μ.toFun s)) K + ↑ε
⊢ False

tactic: simp only [not_exists, not_and, not_le] at hc
state_before: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
H : μ.ContentRegular
K : Compacts G
ε : ℝ≥0
hε : ε ≠ 0
hc : ¬∃ K', K.carrier ⊆ interior K'.carrier ∧ (fun s => ↑(μ.toFun s)) K' ≤ (fun s => ↑(μ.toFun s)) K + ↑ε
⊢ False
state_after: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
H : μ.ContentRegular
K : Compacts G
ε : ℝ≥0
hε : ε ≠ 0
hc : ∀ (x : Compacts G), K.carrier ⊆ interior x.carrier → ↑(μ.toFun K) + ↑ε < ↑(μ.toFun x)
⊢ False

tactic: have lower_bound_iInf : μ K + ε ≤
    ⨅ (K' : TopologicalSpace.Compacts G) (_ : (K : Set G) ⊆ interior (K' : Set G)), μ K' :=
  le_iInf fun K' => le_iInf fun K'_hyp => le_of_lt (hc K' K'_hyp)
state_before: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
H : μ.ContentRegular
K : Compacts G
ε : ℝ≥0
hε : ε ≠ 0
hc : ∀ (x : Compacts G), K.carrier ⊆ interior x.carrier → ↑(μ.toFun K) + ↑ε < ↑(μ.toFun x)
⊢ False
state_after: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
H : μ.ContentRegular
K : Compacts G
ε : ℝ≥0
hε : ε ≠ 0
hc : ∀ (x : Compacts G), K.carrier ⊆ interior x.carrier → ↑(μ.toFun K) + ↑ε < ↑(μ.toFun x)
lower_bound_iInf : (fun s => ↑(μ.toFun s)) K + ↑ε ≤ ⨅ K', ⨅ (_ : ↑K ⊆ interior ↑K'), (fun s => ↑(μ.toFun s)) K'
⊢ False

tactic: rw [← H] at lower_bound_iInf
state_before: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
H : μ.ContentRegular
K : Compacts G
ε : ℝ≥0
hε : ε ≠ 0
hc : ∀ (x : Compacts G), K.carrier ⊆ interior x.carrier → ↑(μ.toFun K) + ↑ε < ↑(μ.toFun x)
lower_bound_iInf : (fun s => ↑(μ.toFun s)) K + ↑ε ≤ ⨅ K', ⨅ (_ : ↑K ⊆ interior ↑K'), (fun s => ↑(μ.toFun s)) K'
⊢ False
state_after: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
H : μ.ContentRegular
K : Compacts G
ε : ℝ≥0
hε : ε ≠ 0
hc : ∀ (x : Compacts G), K.carrier ⊆ interior x.carrier → ↑(μ.toFun K) + ↑ε < ↑(μ.toFun x)
lower_bound_iInf : (fun s => ↑(μ.toFun s)) K + ↑ε ≤ (fun s => ↑(μ.toFun s)) K
⊢ False

tactic: exact (lt_self_iff_false (μ K)).mp (lt_of_le_of_lt' lower_bound_iInf
  (ENNReal.lt_add_right (ne_top_of_lt (μ.lt_top K)) (ENNReal.coe_ne_zero.mpr hε)))
state_before: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
H : μ.ContentRegular
K : Compacts G
ε : ℝ≥0
hε : ε ≠ 0
hc : ∀ (x : Compacts G), K.carrier ⊆ interior x.carrier → ↑(μ.toFun K) + ↑ε < ↑(μ.toFun x)
lower_bound_iInf : (fun s => ↑(μ.toFun s)) K + ↑ε ≤ (fun s => ↑(μ.toFun s)) K
⊢ False
state_after: no goals
Theorem: Fin.coe_eq_castSucc
File: Mathlib/Data/Fin/Basic.lean

tactic: ext
state_before: n m : ℕ
a : Fin n
⊢ ↑↑a = a.castSucc
state_after: case h
n m : ℕ
a : Fin n
⊢ ↑↑↑a = ↑a.castSucc

tactic: exact val_cast_of_lt (Nat.lt.step a.is_lt)
state_before: case h
n m : ℕ
a : Fin n
⊢ ↑↑↑a = ↑a.castSucc
state_after: no goals
Theorem: IsSemiringHom.to_isAddMonoidHom
File: Mathlib/Deprecated/Ring.lean

tactic: apply @‹IsSemiringHom f›.map_add
state_before: α : Type u
β : Type v
inst✝¹ : Semiring α
inst✝ : Semiring β
f : α → β
hf✝ : IsSemiringHom f
x y : α
hf : IsSemiringHom f
⊢ ∀ (x y : α), f (x + y) = f x + f y
state_after: no goals
Theorem: Filter.eventually_prod_principal_iff
File: Mathlib/Order/Filter/Prod.lean

tactic: rw [eventually_iff, eventually_iff, mem_prod_principal]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s✝ : Set α
t : Set β
f : Filter α
g : Filter β
p : α × β → Prop
s : Set β
⊢ (∀ᶠ (x : α × β) in f ×ˢ 𝓟 s, p x) ↔ ∀ᶠ (x : α) in f, ∀ y ∈ s, p (x, y)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s✝ : Set α
t : Set β
f : Filter α
g : Filter β
p : α × β → Prop
s : Set β
⊢ {a | ∀ b ∈ s, (a, b) ∈ {x | p x}} ∈ f ↔ {x | ∀ y ∈ s, p (x, y)} ∈ f

tactic: simp only [mem_setOf_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s✝ : Set α
t : Set β
f : Filter α
g : Filter β
p : α × β → Prop
s : Set β
⊢ {a | ∀ b ∈ s, (a, b) ∈ {x | p x}} ∈ f ↔ {x | ∀ y ∈ s, p (x, y)} ∈ f
state_after: no goals
Theorem: floorDiv_one
File: Mathlib/Algebra/Order/Floor/Div.lean

tactic: simp [zero_lt_one' α]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝⁴ : OrderedSemiring α
inst✝³ : OrderedAddCommMonoid β
inst✝² : MulActionWithZero α β
inst✝¹ : FloorDiv α β
a : α
inst✝ : Nontrivial α
b c : β
⊢ c ≤ b ⌊/⌋ 1 ↔ c ≤ b
state_after: no goals
Theorem: Matroid.map_emptyOn
File: Mathlib/Data/Matroid/Map.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
f✝ : α → β
E I s : Set α
M : Matroid α
N : Matroid β
f : α → β
⊢ InjOn f (emptyOn α).E
state_after: no goals

tactic: simp [← ground_eq_empty_iff]
state_before: α : Type u_1
β : Type u_2
f✝ : α → β
E I s : Set α
M : Matroid α
N : Matroid β
f : α → β
⊢ (emptyOn α).map f ⋯ = emptyOn β
state_after: no goals
Theorem: LowerSet.mem_iSup₂_iff
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp_rw [mem_iSup_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : LE α
S : Set (LowerSet α)
s t : LowerSet α
a : α
f : (i : ι) → κ i → LowerSet α
⊢ a ∈ ⨆ i, ⨆ j, f i j ↔ ∃ i j, a ∈ f i j
state_after: no goals
Theorem: Set.toFinset_setOf
File: Mathlib/Data/Fintype/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s t : Set α
inst✝² : Fintype α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : Fintype ↑{x | p x}
⊢ {x | p x}.toFinset = filter p Finset.univ
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
s t : Set α
inst✝² : Fintype α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : Fintype ↑{x | p x}
a✝ : α
⊢ a✝ ∈ {x | p x}.toFinset ↔ a✝ ∈ filter p Finset.univ

tactic: simp
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
s t : Set α
inst✝² : Fintype α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : Fintype ↑{x | p x}
a✝ : α
⊢ a✝ ∈ {x | p x}.toFinset ↔ a✝ ∈ filter p Finset.univ
state_after: no goals
Theorem: Polynomial.ne_zero_of_trailingDegree_lt
File: Mathlib/Algebra/Polynomial/Degree/TrailingDegree.lean

tactic: simp [h₀]
state_before: R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ∞
h : p.trailingDegree < n
h₀ : p = 0
⊢ n ≤ p.trailingDegree
state_after: no goals
Theorem: set_pi_mem_nhds_iff
File: Mathlib/Topology/Constructions.lean

tactic: rw [nhds_pi, pi_mem_pi_iff hI]
state_before: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
ι : Type u_5
π : ι → Type u_6
κ : Type u_7
inst✝ : TopologicalSpace X
T : (i : ι) → TopologicalSpace (π i)
f : X → (i : ι) → π i
I : Set ι
hI : I.Finite
s : (i : ι) → Set (π i)
a : (i : ι) → π i
⊢ I.pi s ∈ 𝓝 a ↔ ∀ i ∈ I, s i ∈ 𝓝 (a i)
state_after: no goals
Theorem: ContextFreeGrammar.reverse_involutive
File: Mathlib/Computability/ContextFreeGrammar.lean

tactic: intro x
state_before: T : Type uT
⊢ Function.Involutive reverse
state_after: T : Type uT
x : ContextFreeGrammar T
⊢ x.reverse.reverse = x

tactic: simp [ContextFreeGrammar.reverse, ContextFreeRule.reverse_involutive]
state_before: T : Type uT
x : ContextFreeGrammar T
⊢ x.reverse.reverse = x
state_after: no goals
Theorem: Equiv.Perm.IsCycleOn.zpow_apply_eq_zpow_apply
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: rw [Int.modEq_iff_dvd, ← hf.zpow_apply_eq ha]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
s✝ t : Set α
a b x y : α
s : Finset α
hf : f.IsCycleOn ↑s
ha : a ∈ s
m n : ℤ
⊢ (f ^ m) a = (f ^ n) a ↔ m ≡ n [ZMOD ↑s.card]
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
s✝ t : Set α
a b x y : α
s : Finset α
hf : f.IsCycleOn ↑s
ha : a ∈ s
m n : ℤ
⊢ (f ^ m) a = (f ^ n) a ↔ (f ^ (n - m)) a = a

tactic: simp [sub_eq_neg_add, zpow_add, eq_inv_iff_eq, eq_comm]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
s✝ t : Set α
a b x y : α
s : Finset α
hf : f.IsCycleOn ↑s
ha : a ∈ s
m n : ℤ
⊢ (f ^ m) a = (f ^ n) a ↔ (f ^ (n - m)) a = a
state_after: no goals
Theorem: ne_zero_of_irreducible_X_pow_sub_C'
File: Mathlib/FieldTheory/KummerExtension.lean

tactic: rintro rfl
state_before: K : Type u
inst✝ : Field K
n : ℕ
hn : n ≠ 1
a : K
H : Irreducible (X ^ n - C a)
⊢ a ≠ 0
state_after: K : Type u
inst✝ : Field K
n : ℕ
hn : n ≠ 1
H : Irreducible (X ^ n - C 0)
⊢ False

tactic: rw [map_zero, sub_zero] at H
state_before: K : Type u
inst✝ : Field K
n : ℕ
hn : n ≠ 1
H : Irreducible (X ^ n - C 0)
⊢ False
state_after: K : Type u
inst✝ : Field K
n : ℕ
hn : n ≠ 1
H : Irreducible (X ^ n)
⊢ False

tactic: exact not_irreducible_pow hn H
state_before: K : Type u
inst✝ : Field K
n : ℕ
hn : n ≠ 1
H : Irreducible (X ^ n)
⊢ False
state_after: no goals