ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: SimpleGraph.TripartiteFromTriangles.Graph.in₂₀_iff
File: Mathlib/Combinatorics/SimpleGraph/Triangle/Tripartite.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a a' : α
b b' : β
c c' : γ
x : α × β × γ
ε : 𝕜
⊢ (graph t).Adj (in₂ c) (in₀ a) → ∃ b, (a, b, c) ∈ t
state_after: case in₂₀
α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a a' : α
b b' : β
c c' : γ
x : α × β × γ
ε : 𝕜
b✝ : β
a✝ : (a, b✝, c) ∈ t
⊢ ∃ b, (a, b, c) ∈ t
tactic: rintro ⟨⟩
state_before: case in₂₀
α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a a' : α
b b' : β
c c' : γ
x : α × β × γ
ε : 𝕜
b✝ : β
a✝ : (a, b✝, c) ∈ t
⊢ ∃ b, (a, b, c) ∈ t
state_after: no goals
tactic: exact ⟨_, ‹_›⟩
Theorem: MeasureTheory.exists_nonempty_inter_of_measure_univ_lt_sum_measure
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

Proof steps:
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
m✝ : MeasurableSpace α
μ✝ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
m : MeasurableSpace α
μ : Measure α
s : Finset ι
t : ι → Set α
h : ∀ i ∈ s, NullMeasurableSet (t i) μ
H : μ univ < ∑ i ∈ s, μ (t i)
⊢ ∃ i ∈ s, ∃ j ∈ s, ∃ (_ : i ≠ j), (t i ∩ t j).Nonempty
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m✝ : MeasurableSpace α
μ✝ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
m : MeasurableSpace α
μ : Measure α
s : Finset ι
t : ι → Set α
h : ∀ i ∈ s, NullMeasurableSet (t i) μ
H : ∀ i ∈ s, ∀ j ∈ s, i ≠ j → t i ∩ t j = ∅
⊢ ∑ i ∈ s, μ (t i) ≤ μ univ
tactic: contrapose! H
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
m✝ : MeasurableSpace α
μ✝ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
m : MeasurableSpace α
μ : Measure α
s : Finset ι
t : ι → Set α
h : ∀ i ∈ s, NullMeasurableSet (t i) μ
H : ∀ i ∈ s, ∀ j ∈ s, i ≠ j → t i ∩ t j = ∅
⊢ ∑ i ∈ s, μ (t i) ≤ μ univ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m✝ : MeasurableSpace α
μ✝ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
m : MeasurableSpace α
μ : Measure α
s : Finset ι
t : ι → Set α
h : ∀ i ∈ s, NullMeasurableSet (t i) μ
H : ∀ i ∈ s, ∀ j ∈ s, i ≠ j → t i ∩ t j = ∅
⊢ (↑s).Pairwise (AEDisjoint μ on t)
tactic: apply sum_measure_le_measure_univ h
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
m✝ : MeasurableSpace α
μ✝ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
m : MeasurableSpace α
μ : Measure α
s : Finset ι
t : ι → Set α
h : ∀ i ∈ s, NullMeasurableSet (t i) μ
H : ∀ i ∈ s, ∀ j ∈ s, i ≠ j → t i ∩ t j = ∅
⊢ (↑s).Pairwise (AEDisjoint μ on t)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m✝ : MeasurableSpace α
μ✝ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
m : MeasurableSpace α
μ : Measure α
s : Finset ι
t : ι → Set α
h : ∀ i ∈ s, NullMeasurableSet (t i) μ
H : ∀ i ∈ s, ∀ j ∈ s, i ≠ j → t i ∩ t j = ∅
i : ι
hi : i ∈ ↑s
j : ι
hj : j ∈ ↑s
hij : i ≠ j
⊢ (AEDisjoint μ on t) i j
tactic: intro i hi j hj hij
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
m✝ : MeasurableSpace α
μ✝ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
m : MeasurableSpace α
μ : Measure α
s : Finset ι
t : ι → Set α
h : ∀ i ∈ s, NullMeasurableSet (t i) μ
H : ∀ i ∈ s, ∀ j ∈ s, i ≠ j → t i ∩ t j = ∅
i : ι
hi : i ∈ ↑s
j : ι
hj : j ∈ ↑s
hij : i ≠ j
⊢ (AEDisjoint μ on t) i j
state_after: no goals
tactic: exact (disjoint_iff_inter_eq_empty.mpr (H i hi j hj hij)).aedisjoint
Theorem: CategoryTheory.Limits.HasZeroObject.zeroIsoIsInitial_inv
File: Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
t : IsInitial X
⊢ (zeroIsoIsInitial t).inv = 0
state_after: no goals
tactic: ext
Theorem: Matrix.neg_cons
File: Mathlib/Algebra/Group/Fin/Tuple.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
n : ℕ
inst✝ : Neg α
x : α
v : Fin n → α
⊢ -vecCons x v = vecCons (-x) (-v)
state_after: case h
α : Type u_1
M : Type u_2
n : ℕ
inst✝ : Neg α
x : α
v : Fin n → α
i : Fin n.succ
⊢ (-vecCons x v) i = vecCons (-x) (-v) i
tactic: ext i
state_before: case h
α : Type u_1
M : Type u_2
n : ℕ
inst✝ : Neg α
x : α
v : Fin n → α
i : Fin n.succ
⊢ (-vecCons x v) i = vecCons (-x) (-v) i
state_after: no goals
tactic: refine i.cases ?_ ?_ <;> simp
Theorem: AddSubsemigroup.mem_iInf
File: Mathlib/Algebra/Group/Subsemigroup/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
A : Type u_3
inst✝¹ : Mul M
s : Set M
inst✝ : Add A
t : Set A
S✝ : Subsemigroup M
ι : Sort u_4
S : ι → Subsemigroup M
x : M
⊢ x ∈ ⨅ i, S i ↔ ∀ (i : ι), x ∈ S i
state_after: no goals
tactic: simp only [iInf, mem_sInf, Set.forall_mem_range]
Theorem: Units.coe_dvd
File: Mathlib/Algebra/Divisibility/Units.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Monoid α
a b : α
u : αˣ
⊢ a = ↑u * (↑u⁻¹ * a)
state_after: no goals
tactic: simp
Theorem: EulerSine.integral_sin_mul_sin_mul_cos_pow_eq
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/EulerSineProd.lean

Proof steps:
state_before: z : ℂ
n : ℕ
hn : 2 ≤ n
hz : z ≠ 0
der1 :
  ∀ x ∈ uIcc 0 (π / 2),
    HasDerivAt (fun y => ↑(sin y) * ↑(cos y) ^ (n - 1)) (↑(cos x) ^ n - (↑n - 1) * ↑(sin x) ^ 2 * ↑(cos x) ^ (n - 2)) x
⊢ ∫ (x : ℝ) in 0 ..π / 2, Complex.sin (2 * z * ↑x) * ↑(sin x) * ↑(cos x) ^ (n - 1) =
    (↑n / (2 * z) * ∫ (x : ℝ) in 0 ..π / 2, Complex.cos (2 * z * ↑x) * ↑(cos x) ^ n) -
      (↑n - 1) / (2 * z) * ∫ (x : ℝ) in 0 ..π / 2, Complex.cos (2 * z * ↑x) * ↑(cos x) ^ (n - 2)
state_after: case h.e'_2
z : ℂ
n : ℕ
hn : 2 ≤ n
hz : z ≠ 0
der1 :
  ∀ x ∈ uIcc 0 (π / 2),
    HasDerivAt (fun y => ↑(sin y) * ↑(cos y) ^ (n - 1)) (↑(cos x) ^ n - (↑n - 1) * ↑(sin x) ^ 2 * ↑(cos x) ^ (n - 2)) x
⊢ ∫ (x : ℝ) in 0 ..π / 2, Complex.sin (2 * z * ↑x) * ↑(sin x) * ↑(cos x) ^ (n - 1) =
    ∫ (x : ℝ) in 0 ..π / 2, ↑(sin x) * ↑(cos x) ^ (n - 1) * Complex.sin (2 * z * ↑x)

case h.e'_3
z : ℂ
n : ℕ
hn : 2 ≤ n
hz : z ≠ 0
der1 :
  ∀ x ∈ uIcc 0 (π / 2),
    HasDerivAt (fun y => ↑(sin y) * ↑(cos y) ^ (n - 1)) (↑(cos x) ^ n - (↑n - 1) * ↑(sin x) ^ 2 * ↑(cos x) ^ (n - 2)) x
⊢ (↑n / (2 * z) * ∫ (x : ℝ) in 0 ..π / 2, Complex.cos (2 * z * ↑x) * ↑(cos x) ^ n) -
      (↑n - 1) / (2 * z) * ∫ (x : ℝ) in 0 ..π / 2, Complex.cos (2 * z * ↑x) * ↑(cos x) ^ (n - 2) =
    ↑(sin (π / 2)) * ↑(cos (π / 2)) ^ (n - 1) * (-Complex.cos (2 * z * ↑(π / 2)) / (2 * z)) -
        ↑(sin 0) * ↑(cos 0) ^ (n - 1) * (-Complex.cos (2 * z * ↑0) / (2 * z)) -
      ∫ (x : ℝ) in 0 ..π / 2,
        (↑(cos x) ^ n - (↑n - 1) * ↑(sin x) ^ 2 * ↑(cos x) ^ (n - 2)) * (-Complex.cos (2 * z * ↑x) / (2 * z))

case convert_1
z : ℂ
n : ℕ
hn : 2 ≤ n
hz : z ≠ 0
der1 :
  ∀ x ∈ uIcc 0 (π / 2),
    HasDerivAt (fun y => ↑(sin y) * ↑(cos y) ^ (n - 1)) (↑(cos x) ^ n - (↑n - 1) * ↑(sin x) ^ 2 * ↑(cos x) ^ (n - 2)) x
⊢ IntervalIntegrable (fun x => ↑(cos x) ^ n - (↑n - 1) * ↑(sin x) ^ 2 * ↑(cos x) ^ (n - 2)) volume 0 (π / 2)

case convert_2
z : ℂ
n : ℕ
hn : 2 ≤ n
hz : z ≠ 0
der1 :
  ∀ x ∈ uIcc 0 (π / 2),
    HasDerivAt (fun y => ↑(sin y) * ↑(cos y) ^ (n - 1)) (↑(cos x) ^ n - (↑n - 1) * ↑(sin x) ^ 2 * ↑(cos x) ^ (n - 2)) x
⊢ IntervalIntegrable (fun x => Complex.sin (2 * z * ↑x)) volume 0 (π / 2)
tactic: convert
    integral_mul_deriv_eq_deriv_mul der1 (fun x _ => antideriv_sin_comp_const_mul hz x) _ _ using 1
Theorem: FreeAddSemigroup.length_map
File: Mathlib/Algebra/Free.lean

Proof steps:
state_before: α : Type u
β : Type v
f : α → β
x✝ : FreeSemigroup α
x : α
y : FreeSemigroup α
hx : ((map f) (of x)).length = (of x).length
hy : ((map f) y).length = y.length
⊢ ((map f) (of x * y)).length = (of x * y).length
state_after: no goals
tactic: simp only [map_mul, length_mul, *]
Theorem: Matrix.col_cons
File: Mathlib/Data/Matrix/Notation.lean

Proof steps:
state_before: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
ι : Type u_1
x : α
u : Fin m → α
⊢ col ι (vecCons x u) = of (vecCons (fun x_1 => x) (col ι u))
state_after: case a
α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
ι : Type u_1
x : α
u : Fin m → α
i : Fin m.succ
j : ι
⊢ col ι (vecCons x u) i j = of (vecCons (fun x_1 => x) (col ι u)) i j
tactic: ext i j
state_before: case a
α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
ι : Type u_1
x : α
u : Fin m → α
i : Fin m.succ
j : ι
⊢ col ι (vecCons x u) i j = of (vecCons (fun x_1 => x) (col ι u)) i j
state_after: no goals
tactic: refine Fin.cases ?_ ?_ i <;> simp [vecHead, vecTail]
Theorem: nsmul_zmod_val_inv_nsmul
File: Mathlib/Data/ZMod/Basic.lean

Proof steps:
state_before: α : Type u_1
inst✝ : AddGroup α
n : ℕ
hn : (Nat.card α).Coprime n
a : α
⊢ n • (↑n)⁻¹.val • a = a
state_after: no goals
tactic: rw [← mul_nsmul', ← mod_natCard_nsmul, ← ZMod.val_natCast, Nat.cast_mul,
    ZMod.mul_val_inv hn.symm, ZMod.val_one_eq_one_mod, mod_natCard_nsmul, one_nsmul]
Theorem: ContinuousLinearEquiv.comp_contDiff_iff
File: Mathlib/Analysis/Calculus/ContDiff/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
e : F ≃L[𝕜] G
⊢ ContDiff 𝕜 n (⇑e ∘ f) ↔ ContDiff 𝕜 n f
state_after: no goals
tactic: simp only [← contDiffOn_univ, e.comp_contDiffOn_iff]
Theorem: ContDiffBump.normed_le_div_measure_closedBall_rIn
File: Mathlib/Analysis/Calculus/BumpFunction/Normed.lean

Proof steps:
state_before: E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : HasContDiffBump E
inst✝⁴ : MeasurableSpace E
c : E
f : ContDiffBump c
x✝ : E
n : ℕ∞
μ : Measure E
inst✝³ : BorelSpace E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : IsLocallyFiniteMeasure μ
inst✝ : μ.IsOpenPosMeasure
x : E
⊢ f.normed μ x ≤ 1 / (μ (closedBall c f.rIn)).toReal
state_after: E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : HasContDiffBump E
inst✝⁴ : MeasurableSpace E
c : E
f : ContDiffBump c
x✝ : E
n : ℕ∞
μ : Measure E
inst✝³ : BorelSpace E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : IsLocallyFiniteMeasure μ
inst✝ : μ.IsOpenPosMeasure
x : E
⊢ ↑f x / ∫ (x : E), ↑f x ∂μ ≤ 1 / (μ (closedBall c f.rIn)).toReal
tactic: rw [normed_def]
state_before: E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : HasContDiffBump E
inst✝⁴ : MeasurableSpace E
c : E
f : ContDiffBump c
x✝ : E
n : ℕ∞
μ : Measure E
inst✝³ : BorelSpace E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : IsLocallyFiniteMeasure μ
inst✝ : μ.IsOpenPosMeasure
x : E
⊢ ↑f x / ∫ (x : E), ↑f x ∂μ ≤ 1 / (μ (closedBall c f.rIn)).toReal
state_after: case hd
E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : HasContDiffBump E
inst✝⁴ : MeasurableSpace E
c : E
f : ContDiffBump c
x✝ : E
n : ℕ∞
μ : Measure E
inst✝³ : BorelSpace E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : IsLocallyFiniteMeasure μ
inst✝ : μ.IsOpenPosMeasure
x : E
⊢ 0 < (μ (closedBall c f.rIn)).toReal

case hac
E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : HasContDiffBump E
inst✝⁴ : MeasurableSpace E
c : E
f : ContDiffBump c
x✝ : E
n : ℕ∞
μ : Measure E
inst✝³ : BorelSpace E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : IsLocallyFiniteMeasure μ
inst✝ : μ.IsOpenPosMeasure
x : E
⊢ ↑f x ≤ 1

case hbd
E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : HasContDiffBump E
inst✝⁴ : MeasurableSpace E
c : E
f : ContDiffBump c
x✝ : E
n : ℕ∞
μ : Measure E
inst✝³ : BorelSpace E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : IsLocallyFiniteMeasure μ
inst✝ : μ.IsOpenPosMeasure
x : E
⊢ (μ (closedBall c f.rIn)).toReal ≤ ∫ (x : E), ↑f x ∂μ
tactic: gcongr
Theorem: Matroid.ground_eq_empty_iff
File: Mathlib/Data/Matroid/Constructions.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
E B I X R J : Set α
⊢ M.E = ∅ ↔ M = emptyOn α
state_after: α : Type u_1
M : Matroid α
E B I X R J : Set α
⊢ M.E = ∅ → ∀ I ⊆ M.E, M.Indep I ↔ I = ∅
tactic: simp only [emptyOn, eq_iff_indep_iff_indep_forall, iff_self_and]
state_before: α : Type u_1
M : Matroid α
E B I X R J : Set α
⊢ M.E = ∅ → ∀ I ⊆ M.E, M.Indep I ↔ I = ∅
state_after: no goals
tactic: exact fun h ↦ by simp [h, subset_empty_iff]
Theorem: nilradical_eq_sInf
File: Mathlib/RingTheory/Nilpotent/Lemmas.lean

Proof steps:
state_before: R✝ : Type u_1
S : Type u_2
x✝ y✝ : R✝
inst✝¹ : CommSemiring R✝
x y : R✝
R : Type u_3
inst✝ : CommSemiring R
⊢ sInf {J | ⊥ ≤ J ∧ J.IsPrime} = sInf {J | J.IsPrime}
state_after: no goals
tactic: simp_rw [and_iff_right bot_le]
Theorem: Real.arcsin_lt_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

Proof steps:
state_before: x✝ y x : ℝ
⊢ x < sin (π / 2) ↔ x < 1
state_after: no goals
tactic: rw [sin_pi_div_two]
Theorem: Fin.rev_succAbove
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
p✝ : Fin (n + 1)
i✝ j : Fin n
p : Fin (n + 1)
i : Fin n
⊢ (p.succAbove i).rev = p.rev.succAbove i.rev
state_after: no goals
tactic: rw [succAbove_rev_left, rev_rev]
Theorem: iteratedFDeriv_zero_fun
File: Mathlib/Analysis/Calculus/ContDiff/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x✝ x₀ : E
c : F
b : E × F → G
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ
x : E
⊢ iteratedFDeriv 𝕜 n (fun x => 0) x = 0 x
state_after: no goals
tactic: simpa [← iteratedFDerivWithin_univ] using
    iteratedFDerivWithin_zero_fun uniqueDiffOn_univ (mem_univ x)
Theorem: infEdist_cthickening
File: Mathlib/Analysis/NormedSpace/Pointwise.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x✝ y z : E
δ✝ ε δ : ℝ
s : Set E
x : E
⊢ infEdist x (cthickening δ s) = infEdist x s - ENNReal.ofReal δ
state_after: case inl
𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x✝ y z : E
δ✝ ε δ : ℝ
s : Set E
x : E
hδ : δ ≤ 0
⊢ infEdist x (cthickening δ s) = infEdist x s - ENNReal.ofReal δ

case inr
𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x✝ y z : E
δ✝ ε δ : ℝ
s : Set E
x : E
hδ : 0 < δ
⊢ infEdist x (cthickening δ s) = infEdist x s - ENNReal.ofReal δ
tactic: obtain hδ | hδ := le_or_lt δ 0
Theorem: Matroid.Indep.basis_insert_iff
File: Mathlib/Data/Matroid/Basic.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
B I J X Y : Set α
e : α
hI : M.Indep I
⊢ M.Basis I (insert e I) ↔ M.Dep (insert e I) ∨ e ∈ I
state_after: α : Type u_1
M : Matroid α
B I J X Y : Set α
e : α
hI : M.Indep I
⊢ e ∉ I → ¬M.Indep (insert e I) ∧ e ∈ M.E ↔ ¬M.Indep (insert e I) ∧ e ∈ M.E ∨ e ∈ I
tactic: simp_rw [hI.basis_iff_forall_insert_dep (subset_insert _ _), dep_iff, insert_subset_iff,
    and_iff_left hI.subset_ground, mem_diff, mem_insert_iff, or_and_right, and_not_self,
    or_false, and_imp, forall_eq]
state_before: α : Type u_1
M : Matroid α
B I J X Y : Set α
e : α
hI : M.Indep I
⊢ e ∉ I → ¬M.Indep (insert e I) ∧ e ∈ M.E ↔ ¬M.Indep (insert e I) ∧ e ∈ M.E ∨ e ∈ I
state_after: no goals
tactic: tauto
Theorem: Nat.factorial_two_mul_le
File: Mathlib/Data/Nat/Factorial/Basic.lean

Proof steps:
state_before: n : ℕ
⊢ (2 * n)! ≤ (2 * n) ^ n * n !
state_after: n : ℕ
⊢ (n + 1).ascFactorial n * n ! ≤ (n + n) ^ n * n !
tactic: rw [Nat.two_mul, ← factorial_mul_ascFactorial, Nat.mul_comm]
state_before: n : ℕ
⊢ (n + 1).ascFactorial n * n ! ≤ (n + n) ^ n * n !
state_after: no goals
tactic: exact Nat.mul_le_mul_right _ (ascFactorial_le_pow_add _ _)
Theorem: Finset.coe_filterMap
File: Mathlib/Data/Finset/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : α → Option β
s' s t : Finset α
f_inj : ∀ (a a' : α), ∀ b ∈ f a, b ∈ f a' → a = a'
⊢ ∀ (x : β), x ∈ ↑(filterMap f s f_inj) ↔ x ∈ {b | ∃ a ∈ s, f a = some b}
state_after: no goals
tactic: simp only [mem_coe, mem_filterMap, Option.mem_def, Set.mem_setOf_eq, implies_true]
Theorem: MeasureTheory.Measure.restrict_eq_self
File: Mathlib/MeasureTheory/Measure/Restrict.lean

Proof steps:
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 α
h : s ⊆ t
⊢ μ (toMeasurable (μ.restrict t) s ∩ t) = (μ.restrict t) s
state_after: no goals
tactic: rw [← restrict_apply (measurableSet_toMeasurable _ _), measure_toMeasurable]
Theorem: FirstOrder.Language.model_infiniteTheory_iff
File: Mathlib/ModelTheory/Semantics.lean

Proof steps:
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n : ℕ
T : L.Theory
⊢ M ⊨ L.infiniteTheory ↔ Infinite M
state_after: no goals
tactic: simp [infiniteTheory, infinite_iff, aleph0_le]
Theorem: Turing.fun_respects
File: Mathlib/Computability/TuringMachine.lean

Proof steps:
state_before: σ₁ : Type u_1
σ₂ : Type u_2
f₁ : σ₁ → Option σ₁
f₂ : σ₂ → Option σ₂
tr : σ₁ → σ₂
a₁ : σ₁
⊢ (∀ ⦃a₂ : σ₂⦄,
      (fun a b => tr a = b) a₁ a₂ →
        match f₁ a₁ with
        | some b₁ => ∃ b₂, (fun a b => tr a = b) b₁ b₂ ∧ Reaches₁ f₂ a₂ b₂
        | none => f₂ a₂ = none) ↔
    FRespects f₂ tr (tr a₁) (f₁ a₁)
state_after: no goals
tactic: cases f₁ a₁ <;> simp only [FRespects, Respects, exists_eq_left', forall_eq']
Theorem: List.range'_eq_map_range
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: s n : Nat
⊢ range' s n = map (fun x => s + x) (range n)
state_after: s n : Nat
⊢ range' s n = range' (s + 0) n
tactic: rw [range_eq_range', map_add_range']
state_before: s n : Nat
⊢ range' s n = range' (s + 0) n
state_after: no goals
tactic: rfl
Theorem: Irrational.ne_one
File: Mathlib/Data/Real/Irrational.lean

Proof steps:
state_before: x : ℝ
h : Irrational x
⊢ x ≠ 1
state_after: no goals
tactic: simpa only [Nat.cast_one] using h.ne_nat 1
Theorem: finEquivPowers_symm_apply
File: Mathlib/GroupTheory/OrderOfElement.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : LeftCancelMonoid G
x✝ y a : G
m n✝ : ℕ
x : G
hx : IsOfFinOrder x
n : ℕ
hn : ∃ m, x ^ m = x ^ n
⊢ (finEquivPowers x hx).symm ⟨x ^ n, hn⟩ = ⟨n % orderOf x, ⋯⟩
state_after: no goals
tactic: rw [Equiv.symm_apply_eq, finEquivPowers_apply, Subtype.mk_eq_mk, ← pow_mod_orderOf, Fin.val_mk]
Theorem: Int.shiftRight_negSucc
File: Mathlib/Data/Int/Bitwise.lean

Proof steps:
state_before: m n : ℕ
⊢ -[m+1] >>> ↑n = -[m >>> n+1]
state_after: no goals
tactic: cases n <;> rfl
Theorem: affineIndependent_iff_of_fintype
File: Mathlib/LinearAlgebra/AffineSpace/Independent.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
ι : Type u_4
inst✝ : Fintype ι
p : ι → P
⊢ AffineIndependent k p ↔ ∀ (w : ι → k), ∑ i : ι, w i = 0 → (univ.weightedVSub p) w = 0 → ∀ (i : ι), w i = 0
state_after: case mp
k : Type u_1
V : Type u_2
P : Type u_3
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
ι : Type u_4
inst✝ : Fintype ι
p : ι → P
⊢ AffineIndependent k p → ∀ (w : ι → k), ∑ i : ι, w i = 0 → (univ.weightedVSub p) w = 0 → ∀ (i : ι), w i = 0

case mpr
k : Type u_1
V : Type u_2
P : Type u_3
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
ι : Type u_4
inst✝ : Fintype ι
p : ι → P
⊢ (∀ (w : ι → k), ∑ i : ι, w i = 0 → (univ.weightedVSub p) w = 0 → ∀ (i : ι), w i = 0) → AffineIndependent k p
tactic: constructor
Theorem: ModularForm.gradedMonoid_eq_of_cast
File: Mathlib/NumberTheory/ModularForms/Basic.lean

Proof steps:
state_before: Γ : Subgroup SL(2, ℤ)
a b : GradedMonoid (ModularForm Γ)
h : a.fst = b.fst
h2 : mcast h a.snd = b.snd
⊢ a = b
state_after: case mk
Γ : Subgroup SL(2, ℤ)
b : GradedMonoid (ModularForm Γ)
i : ℤ
a : ModularForm Γ i
h : ⟨i, a⟩.fst = b.fst
h2 : mcast h ⟨i, a⟩.snd = b.snd
⊢ ⟨i, a⟩ = b
tactic: obtain ⟨i, a⟩ := a
state_before: case mk
Γ : Subgroup SL(2, ℤ)
b : GradedMonoid (ModularForm Γ)
i : ℤ
a : ModularForm Γ i
h : ⟨i, a⟩.fst = b.fst
h2 : mcast h ⟨i, a⟩.snd = b.snd
⊢ ⟨i, a⟩ = b
state_after: case mk.mk
Γ : Subgroup SL(2, ℤ)
i : ℤ
a : ModularForm Γ i
j : ℤ
b : ModularForm Γ j
h : ⟨i, a⟩.fst = ⟨j, b⟩.fst
h2 : mcast h ⟨i, a⟩.snd = ⟨j, b⟩.snd
⊢ ⟨i, a⟩ = ⟨j, b⟩
tactic: obtain ⟨j, b⟩ := b
state_before: case mk.mk
Γ : Subgroup SL(2, ℤ)
i : ℤ
a : ModularForm Γ i
j : ℤ
b : ModularForm Γ j
h : ⟨i, a⟩.fst = ⟨j, b⟩.fst
h2 : mcast h ⟨i, a⟩.snd = ⟨j, b⟩.snd
⊢ ⟨i, a⟩ = ⟨j, b⟩
state_after: case mk.mk.refl
Γ : Subgroup SL(2, ℤ)
i : ℤ
a b : ModularForm Γ i
h2 : mcast ⋯ ⟨i, a⟩.snd = ⟨i, b⟩.snd
⊢ ⟨i, a⟩ = ⟨i, b⟩
tactic: cases h
state_before: case mk.mk.refl
Γ : Subgroup SL(2, ℤ)
i : ℤ
a b : ModularForm Γ i
h2 : mcast ⋯ ⟨i, a⟩.snd = ⟨i, b⟩.snd
⊢ ⟨i, a⟩ = ⟨i, b⟩
state_after: no goals
tactic: exact congr_arg _ h2
Theorem: Nat.Prime.multiplicity_choose
File: Mathlib/Data/Nat/Multiplicity.lean

Proof steps:
state_before: p n k b : ℕ
hp : Prime p
hkn : k ≤ n
hnb : log p n < b
⊢ multiplicity p (n.choose k) = ↑(filter (fun i => p ^ i ≤ k % p ^ i + (n - k) % p ^ i) (Ico 1 b)).card
state_after: p n k b : ℕ
hp : Prime p
hkn : k ≤ n
hnb : log p n < b
this : n - k + k = n
⊢ multiplicity p (n.choose k) = ↑(filter (fun i => p ^ i ≤ k % p ^ i + (n - k) % p ^ i) (Ico 1 b)).card
tactic: have := Nat.sub_add_cancel hkn
state_before: p n k b : ℕ
hp : Prime p
hkn : k ≤ n
hnb : log p n < b
this : n - k + k = n
⊢ multiplicity p (n.choose k) = ↑(filter (fun i => p ^ i ≤ k % p ^ i + (n - k) % p ^ i) (Ico 1 b)).card
state_after: case h.e'_2.h.e'_5.h.e'_1
p n k b : ℕ
hp : Prime p
hkn : k ≤ n
hnb : log p n < b
this : n - k + k = n
⊢ n = n - k + k

p n k b : ℕ
hp : Prime p
hkn : k ≤ n
hnb : log p n < b
this : n - k + k = n
⊢ log p (n - k + k) < b
tactic: convert @multiplicity_choose' p (n - k) k b hp _
state_before: p n k b : ℕ
hp : Prime p
hkn : k ≤ n
hnb : log p n < b
this : n - k + k = n
⊢ log p (n - k + k) < b
state_after: no goals
tactic: exact this.symm ▸ hnb
Theorem: Real.sq_lt
File: Mathlib/Data/Real/Sqrt.lean

Proof steps:
state_before: x✝ y✝ x y : ℝ
⊢ x ^ 2 < y ↔ -√y < x ∧ x < √y
state_after: no goals
tactic: rw [← abs_lt, ← sq_abs, lt_sqrt (abs_nonneg _)]