ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Nat.mul_add_mod'
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a✝ b✝ c✝ d m n k : ℕ
p q : ℕ → Prop
a b c : ℕ
⊢ (a * b + c) % b = c % b
state_after: no goals
tactic: rw [Nat.mul_comm, Nat.mul_add_mod]
Theorem: NNReal.measurable_of_tendsto'
File: Mathlib/MeasureTheory/Constructions/BorelSpace/Real.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι✝ : Sort y
s t u✝ : Set α
inst✝² : MeasurableSpace α
ι : Type u_5
f : ι → α → ℝ≥0
g : α → ℝ≥0
u : Filter ι
inst✝¹ : u.NeBot
inst✝ : u.IsCountablyGenerated
hf : ∀ (i : ι), Measurable (f i)
lim : Tendsto f u (𝓝 g)
⊢ Measurable g
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι✝ : Sort y
s t u✝ : Set α
inst✝² : MeasurableSpace α
ι : Type u_5
f : ι → α → ℝ≥0
g : α → ℝ≥0
u : Filter ι
inst✝¹ : u.NeBot
inst✝ : u.IsCountablyGenerated
lim : Tendsto f u (𝓝 g)
hf : ∀ (i : ι), Measurable fun x => ↑(f i x)
⊢ Measurable fun x => ↑(g x)
tactic: simp_rw [← measurable_coe_nnreal_ennreal_iff] at hf ⊢
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι✝ : Sort y
s t u✝ : Set α
inst✝² : MeasurableSpace α
ι : Type u_5
f : ι → α → ℝ≥0
g : α → ℝ≥0
u : Filter ι
inst✝¹ : u.NeBot
inst✝ : u.IsCountablyGenerated
lim : Tendsto f u (𝓝 g)
hf : ∀ (i : ι), Measurable fun x => ↑(f i x)
⊢ Measurable fun x => ↑(g x)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι✝ : Sort y
s t u✝ : Set α
inst✝² : MeasurableSpace α
ι : Type u_5
f : ι → α → ℝ≥0
g : α → ℝ≥0
u : Filter ι
inst✝¹ : u.NeBot
inst✝ : u.IsCountablyGenerated
lim : Tendsto f u (𝓝 g)
hf : ∀ (i : ι), Measurable fun x => ↑(f i x)
⊢ Tendsto (fun i x => ↑(f i x)) u (𝓝 fun x => ↑(g x))
tactic: refine ENNReal.measurable_of_tendsto' u hf ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι✝ : Sort y
s t u✝ : Set α
inst✝² : MeasurableSpace α
ι : Type u_5
f : ι → α → ℝ≥0
g : α → ℝ≥0
u : Filter ι
inst✝¹ : u.NeBot
inst✝ : u.IsCountablyGenerated
lim : Tendsto f u (𝓝 g)
hf : ∀ (i : ι), Measurable fun x => ↑(f i x)
⊢ Tendsto (fun i x => ↑(f i x)) u (𝓝 fun x => ↑(g x))
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι✝ : Sort y
s t u✝ : Set α
inst✝² : MeasurableSpace α
ι : Type u_5
f : ι → α → ℝ≥0
g : α → ℝ≥0
u : Filter ι
inst✝¹ : u.NeBot
inst✝ : u.IsCountablyGenerated
lim : ∀ (x : α), Tendsto (fun i => f i x) u (𝓝 (g x))
hf : ∀ (i : ι), Measurable fun x => ↑(f i x)
⊢ ∀ (x : α), Tendsto (fun i => ↑(f i x)) u (𝓝 ↑(g x))
tactic: rw [tendsto_pi_nhds] at lim ⊢
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι✝ : Sort y
s t u✝ : Set α
inst✝² : MeasurableSpace α
ι : Type u_5
f : ι → α → ℝ≥0
g : α → ℝ≥0
u : Filter ι
inst✝¹ : u.NeBot
inst✝ : u.IsCountablyGenerated
lim : ∀ (x : α), Tendsto (fun i => f i x) u (𝓝 (g x))
hf : ∀ (i : ι), Measurable fun x => ↑(f i x)
⊢ ∀ (x : α), Tendsto (fun i => ↑(f i x)) u (𝓝 ↑(g x))
state_after: no goals
tactic: exact fun x => (ENNReal.continuous_coe.tendsto (g x)).comp (lim x)
Theorem: NNReal.exists_lt_of_strictMono
File: Mathlib/Data/NNReal/Basic.lean

Proof steps:
state_before: Γ₀ : Type u_1
inst✝ : LinearOrderedCommGroupWithZero Γ₀
h : Nontrivial Γ₀ˣ
f : Γ₀ →*₀ ℝ≥0
hf : StrictMono ⇑f
r : ℝ≥0
hr : 0 < r
⊢ ∃ d, f ↑d < r
state_after: case intro
Γ₀ : Type u_1
inst✝ : LinearOrderedCommGroupWithZero Γ₀
h : Nontrivial Γ₀ˣ
f : Γ₀ →*₀ ℝ≥0
hf : StrictMono ⇑f
r : ℝ≥0
hr : 0 < r
g : Γ₀ˣ
hg1 : g ≠ 1
⊢ ∃ d, f ↑d < r
tactic: obtain ⟨g, hg1⟩ := (nontrivial_iff_exists_ne (1 : Γ₀ˣ)).mp h
state_before: case intro
Γ₀ : Type u_1
inst✝ : LinearOrderedCommGroupWithZero Γ₀
h : Nontrivial Γ₀ˣ
f : Γ₀ →*₀ ℝ≥0
hf : StrictMono ⇑f
r : ℝ≥0
hr : 0 < r
g : Γ₀ˣ
hg1 : g ≠ 1
⊢ ∃ d, f ↑d < r
state_after: case intro
Γ₀ : Type u_1
inst✝ : LinearOrderedCommGroupWithZero Γ₀
h : Nontrivial Γ₀ˣ
f : Γ₀ →*₀ ℝ≥0
hf : StrictMono ⇑f
r : ℝ≥0
hr : 0 < r
g : Γ₀ˣ
hg1 : g ≠ 1
u : Γ₀ˣ := if g < 1 then g else g⁻¹
hu : u = if g < 1 then g else g⁻¹
⊢ ∃ d, f ↑d < r
tactic: set u : Γ₀ˣ := if g < 1 then g else g⁻¹ with hu
state_before: case intro
Γ₀ : Type u_1
inst✝ : LinearOrderedCommGroupWithZero Γ₀
h : Nontrivial Γ₀ˣ
f : Γ₀ →*₀ ℝ≥0
hf : StrictMono ⇑f
r : ℝ≥0
hr : 0 < r
g : Γ₀ˣ
hg1 : g ≠ 1
u : Γ₀ˣ := if g < 1 then g else g⁻¹
hu : u = if g < 1 then g else g⁻¹
hfu : f ↑u < 1
⊢ ∃ d, f ↑d < r
state_after: case intro.intro
Γ₀ : Type u_1
inst✝ : LinearOrderedCommGroupWithZero Γ₀
h : Nontrivial Γ₀ˣ
f : Γ₀ →*₀ ℝ≥0
hf : StrictMono ⇑f
r : ℝ≥0
hr : 0 < r
g : Γ₀ˣ
hg1 : g ≠ 1
u : Γ₀ˣ := if g < 1 then g else g⁻¹
hu : u = if g < 1 then g else g⁻¹
hfu : f ↑u < 1
n : ℕ
hn : f ↑u ^ n < r
⊢ ∃ d, f ↑d < r
tactic: obtain ⟨n, hn⟩ := exists_pow_lt_of_lt_one hr hfu
state_before: case intro.intro
Γ₀ : Type u_1
inst✝ : LinearOrderedCommGroupWithZero Γ₀
h : Nontrivial Γ₀ˣ
f : Γ₀ →*₀ ℝ≥0
hf : StrictMono ⇑f
r : ℝ≥0
hr : 0 < r
g : Γ₀ˣ
hg1 : g ≠ 1
u : Γ₀ˣ := if g < 1 then g else g⁻¹
hu : u = if g < 1 then g else g⁻¹
hfu : f ↑u < 1
n : ℕ
hn : f ↑u ^ n < r
⊢ ∃ d, f ↑d < r
state_after: case h
Γ₀ : Type u_1
inst✝ : LinearOrderedCommGroupWithZero Γ₀
h : Nontrivial Γ₀ˣ
f : Γ₀ →*₀ ℝ≥0
hf : StrictMono ⇑f
r : ℝ≥0
hr : 0 < r
g : Γ₀ˣ
hg1 : g ≠ 1
u : Γ₀ˣ := if g < 1 then g else g⁻¹
hu : u = if g < 1 then g else g⁻¹
hfu : f ↑u < 1
n : ℕ
hn : f ↑u ^ n < r
⊢ f ↑(u ^ n) < r
tactic: use u ^ n
state_before: case h
Γ₀ : Type u_1
inst✝ : LinearOrderedCommGroupWithZero Γ₀
h : Nontrivial Γ₀ˣ
f : Γ₀ →*₀ ℝ≥0
hf : StrictMono ⇑f
r : ℝ≥0
hr : 0 < r
g : Γ₀ˣ
hg1 : g ≠ 1
u : Γ₀ˣ := if g < 1 then g else g⁻¹
hu : u = if g < 1 then g else g⁻¹
hfu : f ↑u < 1
n : ℕ
hn : f ↑u ^ n < r
⊢ f ↑(u ^ n) < r
state_after: no goals
tactic: rwa [Units.val_pow_eq_pow_val, _root_.map_pow]
Theorem: Zspan.norm_fract_le
File: Mathlib/Algebra/Module/Zlattice/Basic.lean

Proof steps:
state_before: E : Type u_1
ι : Type u_2
K : Type u_3
inst✝⁵ : NormedLinearOrderedField K
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace K E
b : Basis ι K E
inst✝² : FloorRing K
inst✝¹ : Fintype ι
inst✝ : HasSolidNorm K
m : E
⊢ ‖fract b m‖ ≤ ∑ i : ι, ‖b i‖
state_after: no goals
tactic: classical
  calc
    ‖fract b m‖ = ‖∑ i, b.repr (fract b m) i • b i‖ := by rw [b.sum_repr]
    _ = ‖∑ i, Int.fract (b.repr m i) • b i‖ := by simp_rw [repr_fract_apply]
    _ ≤ ∑ i, ‖Int.fract (b.repr m i) • b i‖ := norm_sum_le _ _
    _ = ∑ i, ‖Int.fract (b.repr m i)‖ * ‖b i‖ := by simp_rw [norm_smul]
    _ ≤ ∑ i, ‖b i‖ := Finset.sum_le_sum fun i _ => ?_
  suffices ‖Int.fract ((b.repr m) i)‖ ≤ 1 by
    convert mul_le_mul_of_nonneg_right this (norm_nonneg _ : 0 ≤ ‖b i‖)
    exact (one_mul _).symm
  rw [(norm_one.symm : 1 = ‖(1 : K)‖)]
  apply norm_le_norm_of_abs_le_abs
  rw [abs_one, Int.abs_fract]
  exact le_of_lt (Int.fract_lt_one _)
Theorem: Complex.Gamma_one_half_eq
File: Mathlib/Analysis/SpecialFunctions/Gaussian/GaussianIntegral.lean

Proof steps:
state_before: ⊢ Gamma (1 / 2) = ↑π ^ (1 / 2)
state_after: case h.e'_2

⊢ Gamma (1 / 2) = ↑(Real.Gamma (1 / 2))

case h.e'_3

⊢ ↑π ^ (1 / 2) = ↑√π
tactic: convert congr_arg ((↑) : ℝ → ℂ) Real.Gamma_one_half_eq
Theorem: Metric.hausdorffEdist_ne_top_of_nonempty_of_bounded
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
hs : s.Nonempty
ht : t.Nonempty
bs : Bornology.IsBounded s
bt : Bornology.IsBounded t
⊢ hausdorffEdist s t ≠ ⊤
state_after: case intro
ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
ht : t.Nonempty
bs : Bornology.IsBounded s
bt : Bornology.IsBounded t
cs : α
hcs : cs ∈ s
⊢ hausdorffEdist s t ≠ ⊤
tactic: rcases hs with ⟨cs, hcs⟩
state_before: case intro
ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
ht : t.Nonempty
bs : Bornology.IsBounded s
bt : Bornology.IsBounded t
cs : α
hcs : cs ∈ s
⊢ hausdorffEdist s t ≠ ⊤
state_after: case intro.intro
ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
bs : Bornology.IsBounded s
bt : Bornology.IsBounded t
cs : α
hcs : cs ∈ s
ct : α
hct : ct ∈ t
⊢ hausdorffEdist s t ≠ ⊤
tactic: rcases ht with ⟨ct, hct⟩
state_before: case intro.intro
ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
bs : Bornology.IsBounded s
bt : Bornology.IsBounded t
cs : α
hcs : cs ∈ s
ct : α
hct : ct ∈ t
⊢ hausdorffEdist s t ≠ ⊤
state_after: case intro.intro.intro
ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
bs : Bornology.IsBounded s
bt : Bornology.IsBounded t
cs : α
hcs : cs ∈ s
ct : α
hct : ct ∈ t
rs : ℝ
hrs : s ⊆ closedBall ct rs
⊢ hausdorffEdist s t ≠ ⊤
tactic: rcases bs.subset_closedBall ct with ⟨rs, hrs⟩
state_before: case intro.intro.intro
ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
bs : Bornology.IsBounded s
bt : Bornology.IsBounded t
cs : α
hcs : cs ∈ s
ct : α
hct : ct ∈ t
rs : ℝ
hrs : s ⊆ closedBall ct rs
⊢ hausdorffEdist s t ≠ ⊤
state_after: case intro.intro.intro.intro
ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
bs : Bornology.IsBounded s
bt : Bornology.IsBounded t
cs : α
hcs : cs ∈ s
ct : α
hct : ct ∈ t
rs : ℝ
hrs : s ⊆ closedBall ct rs
rt : ℝ
hrt : t ⊆ closedBall cs rt
⊢ hausdorffEdist s t ≠ ⊤
tactic: rcases bt.subset_closedBall cs with ⟨rt, hrt⟩
state_before: case intro.intro.intro.intro
ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
bs : Bornology.IsBounded s
bt : Bornology.IsBounded t
cs : α
hcs : cs ∈ s
ct : α
hct : ct ∈ t
rs : ℝ
hrs : s ⊆ closedBall ct rs
rt : ℝ
hrt : t ⊆ closedBall cs rt
this : hausdorffEdist s t ≤ ENNReal.ofReal (max rs rt)
⊢ hausdorffEdist s t ≠ ⊤
state_after: no goals
tactic: exact ne_top_of_le_ne_top ENNReal.ofReal_ne_top this
Theorem: mem_ball_symmetry
File: Mathlib/Topology/UniformSpace/Basic.lean

Proof steps:
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
V : Set (β × β)
hV : SymmetricRel V
x y : β
⊢ (x, y) ∈ Prod.swap ⁻¹' V ↔ (x, y) ∈ V
state_after: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
V : Set (β × β)
hV : Prod.swap ⁻¹' V = V
x y : β
⊢ (x, y) ∈ Prod.swap ⁻¹' V ↔ (x, y) ∈ V
tactic: unfold SymmetricRel at hV
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
V : Set (β × β)
hV : Prod.swap ⁻¹' V = V
x y : β
⊢ (x, y) ∈ Prod.swap ⁻¹' V ↔ (x, y) ∈ V
state_after: no goals
tactic: rw [hV]
Theorem: CategoryTheory.Functor.splitEpiBiproductComparison_section_
File: Mathlib/CategoryTheory/Limits/Preserves/Shapes/Biproducts.lean

Proof steps:
state_before: C : Type u₁
inst✝⁶ : Category.{v₁, u₁} C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
inst✝⁴ : HasZeroMorphisms C
inst✝³ : HasZeroMorphisms D
J : Type w₁
F : C ⥤ D
f : J → C
inst✝² : HasBiproduct f
inst✝¹ : HasBiproduct (F.obj ∘ f)
inst✝ : F.PreservesZeroMorphisms
⊢ F.biproductComparison' f ≫ F.biproductComparison f = 𝟙 (⨁ F.obj ∘ f)
state_after: no goals
tactic: aesop
Theorem: pow_three
File: Mathlib/Algebra/Group/Defs.lean

Proof steps:
state_before: G : Type u_1
M : Type u_2
inst✝ : Monoid M
a✝ b c : M
m n : ℕ
a : M
⊢ a ^ 3 = a * (a * a)
state_after: no goals
tactic: rw [pow_succ', pow_two]
Theorem: Con.sSup_eq_conGen
File: Mathlib/GroupTheory/Congruence/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c : Con M
S : Set (Con M)
⊢ sSup S = conGen fun x y => ∃ c ∈ S, c x y
state_after: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c : Con M
S : Set (Con M)
⊢ sSup S = sInf {s | ∀ (x y : M), (∃ c ∈ S, c x y) → s x y}
tactic: rw [conGen_eq]
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c : Con M
S : Set (Con M)
⊢ sSup S = sInf {s | ∀ (x y : M), (∃ c ∈ S, c x y) → s x y}
state_after: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c : Con M
S : Set (Con M)
⊢ upperBounds S = {s | ∀ (x y : M), (∃ c ∈ S, c x y) → s x y}
tactic: apply congr_arg sInf
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c : Con M
S : Set (Con M)
⊢ upperBounds S = {s | ∀ (x y : M), (∃ c ∈ S, c x y) → s x y}
state_after: case h
M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c : Con M
S : Set (Con M)
x✝ : Con M
⊢ x✝ ∈ upperBounds S ↔ x✝ ∈ {s | ∀ (x y : M), (∃ c ∈ S, c x y) → s x y}
tactic: ext
state_before: case h
M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c : Con M
S : Set (Con M)
x✝ : Con M
⊢ x✝ ∈ upperBounds S ↔ x✝ ∈ {s | ∀ (x y : M), (∃ c ∈ S, c x y) → s x y}
state_after: no goals
tactic: exact ⟨fun h _ _ ⟨r, hr⟩ => h hr.1 hr.2, fun h r hS _ _ hr => h _ _ ⟨r, hS, hr⟩⟩
Theorem: RCLike.toStarOrderedRing
File: Mathlib/Analysis/RCLike/Basic.lean

Proof steps:
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z✝ w x y : K
hxy : x ≤ y
z : K
⊢ z + x ≤ z + y
state_after: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z✝ w x y : K
hxy : re x ≤ re y ∧ im x = im y
z : K
⊢ re (z + x) ≤ re (z + y) ∧ im (z + x) = im (z + y)
tactic: rw [RCLike.le_iff_re_im] at *
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z✝ w x y : K
hxy : re x ≤ re y ∧ im x = im y
z : K
⊢ re (z + x) ≤ re (z + y) ∧ im (z + x) = im (z + y)
state_after: no goals
tactic: simpa [map_add, add_le_add_iff_left, add_right_inj] using hxy
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z w x : K
⊢ 0 ≤ x ↔ ∃ s, x = star s * s
state_after: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z w x : K
⊢ 0 ≤ re x ∧ im x = 0 ↔ ∃ s, x = star s * s
tactic: rw [nonneg_iff]
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z w x : K
⊢ 0 ≤ re x ∧ im x = 0 ↔ ∃ s, x = star s * s
state_after: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z w x : K
⊢ (∃ s, x = star s * s) → 0 ≤ re x ∧ im x = 0
tactic: refine ⟨fun h ↦ ⟨√(re x), by simp [ext_iff (K := K), h.1, h.2]⟩, ?_⟩
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z w x : K
⊢ (∃ s, x = star s * s) → 0 ≤ re x ∧ im x = 0
state_after: case intro
K : Type u_1
E : Type u_2
inst✝ : RCLike K
z w s : K
⊢ 0 ≤ re (star s * s) ∧ im (star s * s) = 0
tactic: rintro ⟨s, rfl⟩
state_before: case intro
K : Type u_1
E : Type u_2
inst✝ : RCLike K
z w s : K
⊢ 0 ≤ re (star s * s) ∧ im (star s * s) = 0
state_after: no goals
tactic: simp [mul_comm, mul_self_nonneg, add_nonneg]
Theorem: Filter.limsup_sdiff
File: Mathlib/Order/LiminfLimsup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : CompleteBooleanAlgebra α
f : Filter β
u : β → α
a : α
⊢ limsup u f \ a = limsup (fun b => u b \ a) f
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : CompleteBooleanAlgebra α
f : Filter β
u : β → α
a : α
⊢ (⨅ s ∈ f, ⨆ a ∈ s, u a) ⊓ aᶜ = ⨅ s ∈ f, ⨆ a_1 ∈ s, u a_1 ⊓ aᶜ
tactic: simp only [limsup_eq_iInf_iSup, sdiff_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : CompleteBooleanAlgebra α
f : Filter β
u : β → α
a : α
⊢ (⨅ s ∈ f, ⨆ a ∈ s, u a) ⊓ aᶜ = ⨅ s ∈ f, ⨆ a_1 ∈ s, u a_1 ⊓ aᶜ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : CompleteBooleanAlgebra α
f : Filter β
u : β → α
a : α
⊢ ⨅ i ∈ f, (⨆ a ∈ i, u a) ⊓ aᶜ = ⨅ s ∈ f, ⨆ a_1 ∈ s, u a_1 ⊓ aᶜ
tactic: rw [biInf_inf (⟨univ, univ_mem⟩ : ∃ i : Set β, i ∈ f)]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : CompleteBooleanAlgebra α
f : Filter β
u : β → α
a : α
⊢ ⨅ i ∈ f, (⨆ a ∈ i, u a) ⊓ aᶜ = ⨅ s ∈ f, ⨆ a_1 ∈ s, u a_1 ⊓ aᶜ
state_after: no goals
tactic: simp_rw [inf_comm, inf_iSup₂_eq, inf_comm]
Theorem: Nat.log_anti_left
File: Mathlib/Data/Nat/Log.lean

Proof steps:
state_before: b c n : ℕ
hc : 1 < c
hb : c ≤ b
⊢ log b n ≤ log c n
state_after: case inl
b c : ℕ
hc : 1 < c
hb : c ≤ b
⊢ log b 0 ≤ log c 0

case inr
b c n : ℕ
hc : 1 < c
hb : c ≤ b
hn : n ≠ 0
⊢ log b n ≤ log c n
tactic: rcases eq_or_ne n 0 with (rfl | hn)
state_before: case inr
b c n : ℕ
hc : 1 < c
hb : c ≤ b
hn : n ≠ 0
⊢ log b n ≤ log c n
state_after: case inr
b c n : ℕ
hc : 1 < c
hb : c ≤ b
hn : n ≠ 0
⊢ c ^ log b n ≤ n
tactic: apply le_log_of_pow_le hc
state_before: case inr
b c n : ℕ
hc : 1 < c
hb : c ≤ b
hn : n ≠ 0
⊢ c ^ log b n ≤ n
state_after: no goals
tactic: calc
    c ^ log b n ≤ b ^ log b n := Nat.pow_le_pow_left hb _
    _ ≤ n := pow_log_le_self _ hn
Theorem: MeasureTheory.SimpleFunc.range_eq_empty_of_isEmpty
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

Proof steps:
state_before: α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : MeasurableSpace α
β : Type u_5
hα : IsEmpty α
f : α →ₛ β
⊢ f.range = ∅
state_after: α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : MeasurableSpace α
β : Type u_5
hα : IsEmpty α
f : α →ₛ β
⊢ ¬f.range.Nonempty
tactic: rw [← Finset.not_nonempty_iff_eq_empty]
state_before: α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : MeasurableSpace α
β : Type u_5
hα : IsEmpty α
f : α →ₛ β
⊢ ¬f.range.Nonempty
state_after: α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : MeasurableSpace α
β : Type u_5
hα : IsEmpty α
f : α →ₛ β
h : f.range.Nonempty
⊢ False
tactic: by_contra h
state_before: α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : MeasurableSpace α
β : Type u_5
hα : IsEmpty α
f : α →ₛ β
h : f.range.Nonempty
⊢ False
state_after: case intro
α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : MeasurableSpace α
β : Type u_5
hα : IsEmpty α
f : α →ₛ β
y : β
hy_mem : y ∈ f.range
⊢ False
tactic: obtain ⟨y, hy_mem⟩ := h
state_before: case intro
α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : MeasurableSpace α
β : Type u_5
hα : IsEmpty α
f : α →ₛ β
y : β
hy_mem : y ∈ f.range
⊢ False
state_after: case intro
α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : MeasurableSpace α
β : Type u_5
hα : IsEmpty α
f : α →ₛ β
y : β
hy_mem : ∃ y_1, ↑f y_1 = y
⊢ False
tactic: rw [SimpleFunc.mem_range, Set.mem_range] at hy_mem
state_before: case intro
α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : MeasurableSpace α
β : Type u_5
hα : IsEmpty α
f : α →ₛ β
y : β
hy_mem : ∃ y_1, ↑f y_1 = y
⊢ False
state_after: case intro.intro
α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : MeasurableSpace α
β : Type u_5
hα : IsEmpty α
f : α →ₛ β
y : β
x : α
hxy : ↑f x = y
⊢ False
tactic: obtain ⟨x, hxy⟩ := hy_mem
state_before: case intro.intro
α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : MeasurableSpace α
β : Type u_5
hα : IsEmpty α
f : α →ₛ β
y : β
x : α
hxy : ↑f x = y
⊢ False
state_after: case intro.intro
α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : MeasurableSpace α
β : Type u_5
hα : α → False
f : α →ₛ β
y : β
x : α
hxy : ↑f x = y
⊢ False
tactic: rw [isEmpty_iff] at hα
state_before: case intro.intro
α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : MeasurableSpace α
β : Type u_5
hα : α → False
f : α →ₛ β
y : β
x : α
hxy : ↑f x = y
⊢ False
state_after: no goals
tactic: exact hα x
Theorem: SimpleGraph.cliqueFreeOn_singleton
File: Mathlib/Combinatorics/SimpleGraph/Clique.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G H : SimpleGraph α
s s₁ s₂ : Set α
t : Finset α
a b : α
m n : ℕ
⊢ G.CliqueFreeOn {a} n ↔ 1 < n
state_after: no goals
tactic: obtain _ | _ | n := n <;>
    simp [CliqueFreeOn, isNClique_iff, ← subset_singleton_iff', (Nat.succ_ne_zero _).symm]
Theorem: GaloisField.splits_zmod_X_pow_sub_X
File: Mathlib/FieldTheory/Finite/GaloisField.lean

Proof steps:
state_before: p✝ : ℕ
inst✝ : Fact (Nat.Prime p✝)
n✝ p : ℕ
h_prime : Fact (Nat.Prime p)
n : ℕ
⊢ Splits (RingHom.id (ZMod p)) (X ^ p - X)
state_after: p✝ : ℕ
inst✝ : Fact (Nat.Prime p✝)
n✝ p : ℕ
h_prime : Fact (Nat.Prime p)
n : ℕ
hp : 1 < p
⊢ Splits (RingHom.id (ZMod p)) (X ^ p - X)
tactic: have hp : 1 < p := h_prime.out.one_lt
state_before: p✝ : ℕ
inst✝ : Fact (Nat.Prime p✝)
n✝ p : ℕ
h_prime : Fact (Nat.Prime p)
n : ℕ
hp : 1 < p
⊢ Splits (RingHom.id (ZMod p)) (X ^ p - X)
state_after: p✝ : ℕ
inst✝ : Fact (Nat.Prime p✝)
n✝ p : ℕ
h_prime : Fact (Nat.Prime p)
n : ℕ
hp : 1 < p
h1 : (X ^ p - X).roots = univ.val
⊢ Splits (RingHom.id (ZMod p)) (X ^ p - X)
tactic: have h1 : roots (X ^ p - X : (ZMod p)[X]) = Finset.univ.val := by
    convert FiniteField.roots_X_pow_card_sub_X (ZMod p)
    exact (ZMod.card p).symm
state_before: p✝ : ℕ
inst✝ : Fact (Nat.Prime p✝)
n✝ p : ℕ
h_prime : Fact (Nat.Prime p)
n : ℕ
hp : 1 < p
h1 : (X ^ p - X).roots = univ.val
⊢ Splits (RingHom.id (ZMod p)) (X ^ p - X)
state_after: p✝ : ℕ
inst✝ : Fact (Nat.Prime p✝)
n✝ p : ℕ
h_prime : Fact (Nat.Prime p)
n : ℕ
hp : 1 < p
h1 : (X ^ p - X).roots = univ.val
h2 : (X ^ p - X).natDegree = p
⊢ Splits (RingHom.id (ZMod p)) (X ^ p - X)
tactic: have h2 := FiniteField.X_pow_card_sub_X_natDegree_eq (ZMod p) hp
state_before: p✝ : ℕ
inst✝ : Fact (Nat.Prime p✝)
n✝ p : ℕ
h_prime : Fact (Nat.Prime p)
n : ℕ
hp : 1 < p
h1 : (X ^ p - X).roots = univ.val
h2 : (X ^ p - X).natDegree = p
⊢ Splits (RingHom.id (ZMod p)) (X ^ p - X)
state_after: case zero
p : ℕ
inst✝ : Fact (Nat.Prime p)
n✝ n : ℕ
h_prime : Fact (Nat.Prime 0)
hp : 1 < 0
h1 : (X ^ 0 - X).roots = univ.val
h2 : (X ^ 0 - X).natDegree = 0
⊢ Splits (RingHom.id (ZMod 0)) (X ^ 0 - X)

case succ
p : ℕ
inst✝ : Fact (Nat.Prime p)
n✝¹ n n✝ : ℕ
h_prime : Fact (Nat.Prime (n✝ + 1))
hp : 1 < n✝ + 1
h1 : (X ^ (n✝ + 1) - X).roots = univ.val
h2 : (X ^ (n✝ + 1) - X).natDegree = n✝ + 1
⊢ Splits (RingHom.id (ZMod (n✝ + 1))) (X ^ (n✝ + 1) - X)
tactic: cases p
state_before: case zero
p : ℕ
inst✝ : Fact (Nat.Prime p)
n✝ n : ℕ
h_prime : Fact (Nat.Prime 0)
hp : 1 < 0
h1 : (X ^ 0 - X).roots = univ.val
h2 : (X ^ 0 - X).natDegree = 0
⊢ Splits (RingHom.id (ZMod 0)) (X ^ 0 - X)

case succ
p : ℕ
inst✝ : Fact (Nat.Prime p)
n✝¹ n n✝ : ℕ
h_prime : Fact (Nat.Prime (n✝ + 1))
hp : 1 < n✝ + 1
h1 : (X ^ (n✝ + 1) - X).roots = univ.val
h2 : (X ^ (n✝ + 1) - X).natDegree = n✝ + 1
⊢ Splits (RingHom.id (ZMod (n✝ + 1))) (X ^ (n✝ + 1) - X)
state_after: case succ
p : ℕ
inst✝ : Fact (Nat.Prime p)
n✝¹ n n✝ : ℕ
h_prime : Fact (Nat.Prime (n✝ + 1))
hp : 1 < n✝ + 1
h1 : (X ^ (n✝ + 1) - X).roots = univ.val
h2 : (X ^ (n✝ + 1) - X).natDegree = n✝ + 1
⊢ Splits (RingHom.id (ZMod (n✝ + 1))) (X ^ (n✝ + 1) - X)
tactic: cases hp
state_before: case succ
p : ℕ
inst✝ : Fact (Nat.Prime p)
n✝¹ n n✝ : ℕ
h_prime : Fact (Nat.Prime (n✝ + 1))
hp : 1 < n✝ + 1
h1 : (X ^ (n✝ + 1) - X).roots = univ.val
h2 : (X ^ (n✝ + 1) - X).natDegree = n✝ + 1
⊢ Splits (RingHom.id (ZMod (n✝ + 1))) (X ^ (n✝ + 1) - X)
state_after: no goals
tactic: rw [splits_iff_card_roots, h1, ← Finset.card_def, Finset.card_univ, h2, ZMod.card]
Theorem: CategoryTheory.MonoidalOpposite.unmopBraidedFunctor_obj
File: Mathlib/CategoryTheory/Monoidal/Braided/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝⁸ : Category.{v₁, u₁} C
inst✝⁷ : MonoidalCategory C
inst✝⁶ : BraidedCategory C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
inst✝⁴ : MonoidalCategory D
inst✝³ : BraidedCategory D
E : Type u₃
inst✝² : Category.{v₃, u₃} E
inst✝¹ : MonoidalCategory E
inst✝ : BraidedCategory E
X Y Z : Cᴹᵒᵖ
⊢ (fun X Y => (β_ X.unmop Y.unmop).hom) X Y ▷ __spread✝⁻⁰.obj Z ≫
      (fun X Y => (β_ X.unmop Y.unmop).hom) (X ⊗ Y) Z ≫ __spread✝⁻⁰.map (α_ X Y Z).hom =
    (α_ (__spread✝⁻⁰.obj X) (__spread✝⁻⁰.obj Y) (__spread✝⁻⁰.obj Z)).hom ≫
      __spread✝⁻⁰.obj X ◁ (fun X Y => (β_ X.unmop Y.unmop).hom) Y Z ≫ (fun X Y => (β_ X.unmop Y.unmop).hom) X (Y ⊗ Z)
state_after: no goals
tactic: simp [← yang_baxter_assoc]