ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: NNReal.list_prod_map_rpow'
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

Proof steps:
state_before: w x y z : ℝ
ι : Type u_1
l : List ι
f : ι → ℝ≥0
r : ℝ
⊢ (List.map (fun x => f x ^ r) l).prod = (List.map f l).prod ^ r
state_after: w x y z : ℝ
ι : Type u_1
l : List ι
f : ι → ℝ≥0
r : ℝ
⊢ (List.map (fun x => f x ^ r) l).prod = (List.map ((fun x => x ^ r) ∘ f) l).prod
tactic: rw [← list_prod_map_rpow, List.map_map]
state_before: w x y z : ℝ
ι : Type u_1
l : List ι
f : ι → ℝ≥0
r : ℝ
⊢ (List.map (fun x => f x ^ r) l).prod = (List.map ((fun x => x ^ r) ∘ f) l).prod
state_after: no goals
tactic: rfl
Theorem: List.rel_reverse
File: Mathlib/Data/List/Forall2.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
a✝ : α
b✝ : β
l₁✝ : List α
l₂✝ : List β
h₁ : R a✝ b✝
h₂ : Forall₂ R l₁✝ l₂✝
⊢ Forall₂ R (a✝ :: l₁✝).reverse (b✝ :: l₂✝).reverse
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
a✝ : α
b✝ : β
l₁✝ : List α
l₂✝ : List β
h₁ : R a✝ b✝
h₂ : Forall₂ R l₁✝ l₂✝
⊢ Forall₂ R (l₁✝.reverse ++ [a✝]) (l₂✝.reverse ++ [b✝])
tactic: simp only [reverse_cons]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
a✝ : α
b✝ : β
l₁✝ : List α
l₂✝ : List β
h₁ : R a✝ b✝
h₂ : Forall₂ R l₁✝ l₂✝
⊢ Forall₂ R (l₁✝.reverse ++ [a✝]) (l₂✝.reverse ++ [b✝])
state_after: no goals
tactic: exact rel_append (rel_reverse h₂) (Forall₂.cons h₁ Forall₂.nil)
Theorem: ENNReal.le_rpow_inv_iff
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

Proof steps:
state_before: x y : ℝ≥0∞
z : ℝ
hz : 0 < z
⊢ x ≤ y ^ z⁻¹ ↔ x ^ z ≤ y
state_after: x y : ℝ≥0∞
z : ℝ
hz : 0 < z
⊢ x ^ 1 ≤ y ^ z⁻¹ ↔ x ^ z ≤ y
tactic: nth_rw 1 [← rpow_one x]
state_before: x y : ℝ≥0∞
z : ℝ
hz : 0 < z
⊢ x ^ 1 ≤ y ^ z⁻¹ ↔ x ^ z ≤ y
state_after: x y : ℝ≥0∞
z : ℝ
hz : 0 < z
⊢ x ^ (z * z⁻¹) ≤ y ^ z⁻¹ ↔ x ^ z ≤ y
tactic: nth_rw 1 [← @_root_.mul_inv_cancel _ _ z hz.ne']
state_before: x y : ℝ≥0∞
z : ℝ
hz : 0 < z
⊢ x ^ (z * z⁻¹) ≤ y ^ z⁻¹ ↔ x ^ z ≤ y
state_after: no goals
tactic: rw [rpow_mul, @rpow_le_rpow_iff _ _ z⁻¹ (by simp [hz])]
Theorem: EuclideanGeometry.circumsphere_eq_of_cospherical_subset
File: Mathlib/Geometry/Euclidean/Circumcenter.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
ps : Set P
h : ps ⊆ ↑s
inst✝¹ : Nonempty ↥s
n : ℕ
inst✝ : FiniteDimensional ℝ ↥s.direction
hd : finrank ℝ ↥s.direction = n
hc : Cospherical ps
sx₁ sx₂ : Simplex ℝ P n
hsx₁ : Set.range sx₁.points ⊆ ps
hsx₂ : Set.range sx₂.points ⊆ ps
⊢ sx₁.circumsphere = sx₂.circumsphere
state_after: case intro
V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
ps : Set P
h : ps ⊆ ↑s
inst✝¹ : Nonempty ↥s
n : ℕ
inst✝ : FiniteDimensional ℝ ↥s.direction
hd : finrank ℝ ↥s.direction = n
hc : Cospherical ps
sx₁ sx₂ : Simplex ℝ P n
hsx₁ : Set.range sx₁.points ⊆ ps
hsx₂ : Set.range sx₂.points ⊆ ps
r : Sphere P
hr : ∀ (sx : Simplex ℝ P n), Set.range sx.points ⊆ ps → sx.circumsphere = r
⊢ sx₁.circumsphere = sx₂.circumsphere
tactic: rcases exists_circumsphere_eq_of_cospherical_subset h hd hc with ⟨r, hr⟩
state_before: case intro
V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
ps : Set P
h : ps ⊆ ↑s
inst✝¹ : Nonempty ↥s
n : ℕ
inst✝ : FiniteDimensional ℝ ↥s.direction
hd : finrank ℝ ↥s.direction = n
hc : Cospherical ps
sx₁ sx₂ : Simplex ℝ P n
hsx₁ : Set.range sx₁.points ⊆ ps
hsx₂ : Set.range sx₂.points ⊆ ps
r : Sphere P
hr : ∀ (sx : Simplex ℝ P n), Set.range sx.points ⊆ ps → sx.circumsphere = r
⊢ sx₁.circumsphere = sx₂.circumsphere
state_after: no goals
tactic: rw [hr sx₁ hsx₁, hr sx₂ hsx₂]
Theorem: nat_sub_dvd_pow_sub_pow
File: Mathlib/Algebra/GeomSum.lean

Proof steps:
state_before: α : Type u
x y n : ℕ
⊢ x - y ∣ x ^ n - y ^ n
state_after: case inl
α : Type u
x y n : ℕ
h : y ≤ x
⊢ x - y ∣ x ^ n - y ^ n

case inr
α : Type u
x y n : ℕ
h : x < y
⊢ x - y ∣ x ^ n - y ^ n
tactic: rcases le_or_lt y x with h | h
Theorem: NormedSpace.expSeries_apply_zero
File: Mathlib/Analysis/NormedSpace/Exponential.lean

Proof steps:
state_before: 𝕂 : Type u_1
𝔸 : Type u_2
inst✝⁴ : Field 𝕂
inst✝³ : Ring 𝔸
inst✝² : Algebra 𝕂 𝔸
inst✝¹ : TopologicalSpace 𝔸
inst✝ : TopologicalRing 𝔸
n : ℕ
⊢ ((expSeries 𝕂 𝔸 n) fun x => 0) = Pi.single 0 1 n
state_after: 𝕂 : Type u_1
𝔸 : Type u_2
inst✝⁴ : Field 𝕂
inst✝³ : Ring 𝔸
inst✝² : Algebra 𝕂 𝔸
inst✝¹ : TopologicalSpace 𝔸
inst✝ : TopologicalRing 𝔸
n : ℕ
⊢ (↑n !)⁻¹ • 0 ^ n = Pi.single 0 1 n
tactic: rw [expSeries_apply_eq]
state_before: 𝕂 : Type u_1
𝔸 : Type u_2
inst✝⁴ : Field 𝕂
inst✝³ : Ring 𝔸
inst✝² : Algebra 𝕂 𝔸
inst✝¹ : TopologicalSpace 𝔸
inst✝ : TopologicalRing 𝔸
n : ℕ
⊢ (↑n !)⁻¹ • 0 ^ n = Pi.single 0 1 n
state_after: case zero
𝕂 : Type u_1
𝔸 : Type u_2
inst✝⁴ : Field 𝕂
inst✝³ : Ring 𝔸
inst✝² : Algebra 𝕂 𝔸
inst✝¹ : TopologicalSpace 𝔸
inst✝ : TopologicalRing 𝔸
⊢ (↑0!)⁻¹ • 0 ^ 0 = Pi.single 0 1 0

case succ
𝕂 : Type u_1
𝔸 : Type u_2
inst✝⁴ : Field 𝕂
inst✝³ : Ring 𝔸
inst✝² : Algebra 𝕂 𝔸
inst✝¹ : TopologicalSpace 𝔸
inst✝ : TopologicalRing 𝔸
n : ℕ
⊢ (↑(n + 1)!)⁻¹ • 0 ^ (n + 1) = Pi.single 0 1 (n + 1)
tactic: cases' n with n
Theorem: AffineBasis.coord_apply_combination_of_mem
File: Mathlib/LinearAlgebra/AffineSpace/Basis.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
k : Type u_3
V : Type u_4
P : Type u_5
inst✝³ : AddCommGroup V
inst✝² : AffineSpace V P
inst✝¹ : Ring k
inst✝ : Module k V
b : AffineBasis ι k P
s : Finset ι
i j : ι
e : ι ≃ ι'
hi : i ∈ s
w : ι → k
hw : s.sum w = 1
⊢ (b.coord i) ((Finset.affineCombination k s ⇑b) w) = w i
state_after: no goals
tactic: classical simp only [coord_apply, hi, Finset.affineCombination_eq_linear_combination, if_true,
      mul_boole, hw, Function.comp_apply, smul_eq_mul, s.sum_ite_eq,
      s.map_affineCombination b w hw]
Theorem: Batteries.BinomialHeap.Imp.Heap.realSize_tail?
File: .lake/packages/batteries/Batteries/Data/BinomialHeap/Basic.lean

Proof steps:
state_before: α : Type u_1
le : α → α → Bool
s' s : Heap α
⊢ tail? le s = some s' → s.realSize = s'.realSize + 1
state_after: α : Type u_1
le : α → α → Bool
s' s : Heap α
⊢ Option.map (fun x => x.snd) (deleteMin le s) = some s' → s.realSize = s'.realSize + 1
tactic: simp only [Heap.tail?]
state_before: α : Type u_1
le : α → α → Bool
s' s : Heap α
⊢ Option.map (fun x => x.snd) (deleteMin le s) = some s' → s.realSize = s'.realSize + 1
state_after: α : Type u_1
le : α → α → Bool
s' s : Heap α
eq : Option.map (fun x => x.snd) (deleteMin le s) = some s'
⊢ s.realSize = s'.realSize + 1
tactic: intro eq
state_before: α : Type u_1
le : α → α → Bool
s' s : Heap α
eq : Option.map (fun x => x.snd) (deleteMin le s) = some s'
⊢ s.realSize = s'.realSize + 1
state_after: no goals
tactic: match eq₂ : s.deleteMin le, eq with
  | some (a, tl), rfl => exact realSize_deleteMin eq₂
Theorem: Submodule.set_smul_bot
File: Mathlib/Algebra/Module/Submodule/Pointwise.lean

Proof steps:
state_before: α : Type u_1
R : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
S : Type u_4
inst✝³ : Monoid S
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DistribMulAction S M
sR : Set R
s : Set S
N : Submodule R M
x : M
hx : x ∈ s • ⊥
⊢ x ∈ ⊥
state_after: no goals
tactic: induction x, hx using set_smul_inductionOn <;> aesop
Theorem: continuousOn_update_iff
File: Mathlib/Topology/Separation.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝³ : TopologicalSpace X
inst✝² : T1Space X
inst✝¹ : DecidableEq X
inst✝ : TopologicalSpace Y
f : X → Y
s : Set X
x : X
y : Y
⊢ ContinuousOn (update f x y) s ↔ ContinuousOn f (s \ {x}) ∧ (x ∈ s → Tendsto f (𝓝[s \ {x}] x) (𝓝 y))
state_after: X : Type u_1
Y : Type u_2
inst✝³ : TopologicalSpace X
inst✝² : T1Space X
inst✝¹ : DecidableEq X
inst✝ : TopologicalSpace Y
f : X → Y
s : Set X
x : X
y : Y
⊢ (∀ (b : X), b ≠ x → b ∈ s → ContinuousWithinAt (update f x y) s b) ∧ (x ∈ s → ContinuousWithinAt (update f x y) s x) ↔
    ContinuousOn f (s \ {x}) ∧ (x ∈ s → Tendsto f (𝓝[s \ {x}] x) (𝓝 y))
tactic: rw [ContinuousOn, ← and_forall_ne x, and_comm]
state_before: X : Type u_1
Y : Type u_2
inst✝³ : TopologicalSpace X
inst✝² : T1Space X
inst✝¹ : DecidableEq X
inst✝ : TopologicalSpace Y
f : X → Y
s : Set X
x : X
y : Y
⊢ (∀ (b : X), b ≠ x → b ∈ s → ContinuousWithinAt (update f x y) s b) ∧ (x ∈ s → ContinuousWithinAt (update f x y) s x) ↔
    ContinuousOn f (s \ {x}) ∧ (x ∈ s → Tendsto f (𝓝[s \ {x}] x) (𝓝 y))
state_after: case refine_1
X : Type u_1
Y : Type u_2
inst✝³ : TopologicalSpace X
inst✝² : T1Space X
inst✝¹ : DecidableEq X
inst✝ : TopologicalSpace Y
f : X → Y
s : Set X
x : X
y : Y
H : ∀ (b : X), b ≠ x → b ∈ s → ContinuousWithinAt (update f x y) s b
z : X
hz : z ∈ s \ {x}
⊢ ContinuousWithinAt f (s \ {x}) z

case refine_2
X : Type u_1
Y : Type u_2
inst✝³ : TopologicalSpace X
inst✝² : T1Space X
inst✝¹ : DecidableEq X
inst✝ : TopologicalSpace Y
f : X → Y
s : Set X
x : X
y : Y
H : ContinuousOn f (s \ {x})
z : X
hzx : z ≠ x
hzs : z ∈ s
⊢ ContinuousWithinAt (update f x y) s z

case refine_3
X : Type u_1
Y : Type u_2
inst✝³ : TopologicalSpace X
inst✝² : T1Space X
inst✝¹ : DecidableEq X
inst✝ : TopologicalSpace Y
f : X → Y
s : Set X
x : X
y : Y
x✝ : x ∈ s
⊢ ContinuousWithinAt (update f x y) s x ↔ Tendsto f (𝓝[s \ {x}] x) (𝓝 y)
tactic: refine and_congr ⟨fun H z hz => ?_, fun H z hzx hzs => ?_⟩ (forall_congr' fun _ => ?_)
Theorem: Nat.shiftLeft_lt
File: Mathlib/Data/Nat/Bitwise.lean

Proof steps:
state_before: x n m : ℕ
h : x < 2 ^ n
⊢ x <<< m < 2 ^ (n + m)
state_after: no goals
tactic: simp only [Nat.pow_add, shiftLeft_eq, Nat.mul_lt_mul_right (Nat.two_pow_pos _), h]
Theorem: CategoryTheory.MonoidalNatIso.ofComponents.inv_app
File: Mathlib/CategoryTheory/Monoidal/NaturalTransformation.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F G : LaxMonoidalFunctor C D
app : (X : C) → F.obj X ≅ G.obj X
naturality : ∀ {X Y : C} (f : X ⟶ Y), F.map f ≫ (app Y).hom = (app X).hom ≫ G.map f
unit : F.ε ≫ (app (𝟙_ C)).hom = G.ε
tensor : ∀ (X Y : C), F.μ X Y ≫ (app (X ⊗ Y)).hom = ((app X).hom ⊗ (app Y).hom) ≫ G.μ X Y
X : C
⊢ (ofComponents app naturality unit tensor).inv.app X = (app X).inv
state_after: no goals
tactic: simp [ofComponents]
Theorem: Dioph.mod_dioph
File: Mathlib/NumberTheory/Dioph.lean

Proof steps:
state_before: α β : Type
n : ℕ
f g : (α → ℕ) → ℕ
df : DiophFn f
dg : DiophFn g
this : Dioph fun v => (v &2 = 0 ∨ v &0 < v &2) ∧ ∃ x, v &0 + v &2 * x = v &1
z x y : ℕ
x✝ : (y = 0 ∨ z < y) ∧ ∃ c, z + y * c = x
h : y = 0 ∨ z < y
c : ℕ
hc : z + y * c = x
⊢ x % y = z
state_after: α β : Type
n : ℕ
f g : (α → ℕ) → ℕ
df : DiophFn f
dg : DiophFn g
this : Dioph fun v => (v &2 = 0 ∨ v &0 < v &2) ∧ ∃ x, v &0 + v &2 * x = v &1
z x y : ℕ
x✝ : (y = 0 ∨ z < y) ∧ ∃ c, z + y * c = x
h : y = 0 ∨ z < y
c : ℕ
hc : z + y * c = x
⊢ (z + y * c) % y = z
tactic: rw [← hc]
state_before: α β : Type
n : ℕ
f g : (α → ℕ) → ℕ
df : DiophFn f
dg : DiophFn g
this : Dioph fun v => (v &2 = 0 ∨ v &0 < v &2) ∧ ∃ x, v &0 + v &2 * x = v &1
z x y : ℕ
x✝ : (y = 0 ∨ z < y) ∧ ∃ c, z + y * c = x
h : y = 0 ∨ z < y
c : ℕ
hc : z + y * c = x
⊢ (z + y * c) % y = z
state_after: α β : Type
n : ℕ
f g : (α → ℕ) → ℕ
df : DiophFn f
dg : DiophFn g
this : Dioph fun v => (v &2 = 0 ∨ v &0 < v &2) ∧ ∃ x, v &0 + v &2 * x = v &1
z x y : ℕ
x✝ : (y = 0 ∨ z < y) ∧ ∃ c, z + y * c = x
h : y = 0 ∨ z < y
c : ℕ
hc : z + y * c = x
⊢ z % y = z
tactic: simp
state_before: α β : Type
n : ℕ
f g : (α → ℕ) → ℕ
df : DiophFn f
dg : DiophFn g
this : Dioph fun v => (v &2 = 0 ∨ v &0 < v &2) ∧ ∃ x, v &0 + v &2 * x = v &1
z x y : ℕ
x✝ : (y = 0 ∨ z < y) ∧ ∃ c, z + y * c = x
h : y = 0 ∨ z < y
c : ℕ
hc : z + y * c = x
⊢ z % y = z
state_after: case inl
α β : Type
n : ℕ
f g : (α → ℕ) → ℕ
df : DiophFn f
dg : DiophFn g
this : Dioph fun v => (v &2 = 0 ∨ v &0 < v &2) ∧ ∃ x, v &0 + v &2 * x = v &1
z x y : ℕ
x✝ : (y = 0 ∨ z < y) ∧ ∃ c, z + y * c = x
c : ℕ
hc : z + y * c = x
x0 : y = 0
⊢ z % y = z

case inr
α β : Type
n : ℕ
f g : (α → ℕ) → ℕ
df : DiophFn f
dg : DiophFn g
this : Dioph fun v => (v &2 = 0 ∨ v &0 < v &2) ∧ ∃ x, v &0 + v &2 * x = v &1
z x y : ℕ
x✝ : (y = 0 ∨ z < y) ∧ ∃ c, z + y * c = x
c : ℕ
hc : z + y * c = x
hl : z < y
⊢ z % y = z
tactic: cases' h with x0 hl
state_before: case inr
α β : Type
n : ℕ
f g : (α → ℕ) → ℕ
df : DiophFn f
dg : DiophFn g
this : Dioph fun v => (v &2 = 0 ∨ v &0 < v &2) ∧ ∃ x, v &0 + v &2 * x = v &1
z x y : ℕ
x✝ : (y = 0 ∨ z < y) ∧ ∃ c, z + y * c = x
c : ℕ
hc : z + y * c = x
hl : z < y
⊢ z % y = z
state_after: no goals
tactic: exact mod_eq_of_lt hl
state_before: α β : Type
n : ℕ
f g : (α → ℕ) → ℕ
df : DiophFn f
dg : DiophFn g
this : Dioph fun v => (v &2 = 0 ∨ v &0 < v &2) ∧ ∃ x, v &0 + v &2 * x = v &1
z x y : ℕ
e : x % y = z
⊢ (y = 0 ∨ z < y) ∧ ∃ c, z + y * c = x
state_after: α β : Type
n : ℕ
f g : (α → ℕ) → ℕ
df : DiophFn f
dg : DiophFn g
this : Dioph fun v => (v &2 = 0 ∨ v &0 < v &2) ∧ ∃ x, v &0 + v &2 * x = v &1
z x y : ℕ
e : x % y = z
⊢ (y = 0 ∨ x % y < y) ∧ ∃ c, x % y + y * c = x
tactic: rw [← e]
state_before: α β : Type
n : ℕ
f g : (α → ℕ) → ℕ
df : DiophFn f
dg : DiophFn g
this : Dioph fun v => (v &2 = 0 ∨ v &0 < v &2) ∧ ∃ x, v &0 + v &2 * x = v &1
z x y : ℕ
e : x % y = z
⊢ (y = 0 ∨ x % y < y) ∧ ∃ c, x % y + y * c = x
state_after: no goals
tactic: exact ⟨or_iff_not_imp_left.2 fun h => mod_lt _ (Nat.pos_of_ne_zero h), x / y,
                  mod_add_div _ _⟩
Theorem: MeasureTheory.Martingale.ae_not_tendsto_atTop_atBot
File: Mathlib/Probability/Martingale/BorelCantelli.lean

Proof steps:
state_before: Ω : Type u_1
m0 : MeasurableSpace Ω
μ : Measure Ω
ℱ : Filtration ℕ m0
f : ℕ → Ω → ℝ
ω : Ω
r : ℝ
R : ℝ≥0
inst✝ : IsFiniteMeasure μ
hf : Martingale f ℱ μ
hbdd : ∀ᵐ (ω : Ω) ∂μ, ∀ (i : ℕ), |f (i + 1) ω - f i ω| ≤ ↑R
⊢ ∀ᵐ (ω : Ω) ∂μ, ¬Tendsto (fun n => f n ω) atTop atBot
state_after: no goals
tactic: filter_upwards [hf.bddAbove_range_iff_bddBelow_range hbdd] with ω hω htop using
    unbounded_of_tendsto_atBot htop (hω.1 <| bddAbove_range_of_tendsto_atTop_atBot htop)
Theorem: MeasureTheory.eLpNormEssSup_zero
File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
⊢ eLpNormEssSup 0 μ = 0
state_after: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
⊢ essSup (fun x => ⊥) μ = ⊥
tactic: simp_rw [eLpNormEssSup, Pi.zero_apply, nnnorm_zero, ENNReal.coe_zero, ← ENNReal.bot_eq_zero]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
⊢ essSup (fun x => ⊥) μ = ⊥
state_after: no goals
tactic: exact essSup_const_bot
Theorem: ZFSet.pair_mem_prod
File: Mathlib/SetTheory/ZFC/Basic.lean

Proof steps:
state_before: x y a b : ZFSet
⊢ a.pair b ∈ x.prod y ↔ a ∈ x ∧ b ∈ y
state_after: no goals
tactic: simp
Theorem: Nat.periodic_gcd
File: Mathlib/Data/Nat/Periodic.lean

Proof steps:
state_before: a : ℕ
⊢ Periodic a.gcd a
state_after: no goals
tactic: simp only [forall_const, gcd_add_self_right, eq_self_iff_true, Periodic]
Theorem: MeasureTheory.dirac_eq_dirac_iff_forall_mem_iff_mem
File: Mathlib/MeasureTheory/Measure/Dirac.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
s : Set α
a x y : α
⊢ dirac x = dirac y ↔ ∀ (A : Set α), MeasurableSet A → (x ∈ A ↔ y ∈ A)
state_after: case mp
α : Type u_1
β : Type u_2
δ : Type u_3
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
s : Set α
a x y : α
⊢ dirac x = dirac y → ∀ (A : Set α), MeasurableSet A → (x ∈ A ↔ y ∈ A)

case mpr
α : Type u_1
β : Type u_2
δ : Type u_3
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
s : Set α
a x y : α
⊢ (∀ (A : Set α), MeasurableSet A → (x ∈ A ↔ y ∈ A)) → dirac x = dirac y
tactic: constructor
Theorem: Orientation.cos_oangle_eq_cos_angle
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean

Proof steps:
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x y : V
hx : x ≠ 0
hy : y ≠ 0
⊢ (o.oangle x y).cos = Real.cos (InnerProductGeometry.angle x y)
state_after: no goals
tactic: rw [o.cos_oangle_eq_inner_div_norm_mul_norm hx hy, InnerProductGeometry.cos_angle]
Theorem: CochainComplex.HomComplex.Cochain.v_comp_XIsoOfEq_inv
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
γ : Cochain F G n
p q q' : ℤ
hpq : p + n = q
hq' : q' = q
⊢ p + n = q'
state_after: no goals
tactic: rw [hq', hpq]
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
γ : Cochain F G n
p q q' : ℤ
hpq : p + n = q
hq' : q' = q
⊢ γ.v p q hpq ≫ (HomologicalComplex.XIsoOfEq G hq').inv = γ.v p q' ⋯
state_after: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
γ : Cochain F G n
p q' : ℤ
hpq : p + n = q'
⊢ γ.v p q' hpq ≫ (HomologicalComplex.XIsoOfEq G ⋯).inv = γ.v p q' ⋯
tactic: subst hq'
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
γ : Cochain F G n
p q' : ℤ
hpq : p + n = q'
⊢ γ.v p q' hpq ≫ (HomologicalComplex.XIsoOfEq G ⋯).inv = γ.v p q' ⋯
state_after: no goals
tactic: simp only [HomologicalComplex.XIsoOfEq, eqToIso_refl, Iso.refl_inv, comp_id]
Theorem: mabs_le_mabs_of_one_le
File: Mathlib/Algebra/Order/Group/Unbundled/Abs.lean

Proof steps:
state_before: α : Type u_1
inst✝² : Lattice α
inst✝¹ : Group α
a b : α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
ha : 1 ≤ a
hab : a ≤ b
⊢ mabs a ≤ mabs b
state_after: no goals
tactic: rwa [mabs_of_one_le ha, mabs_of_one_le (ha.trans hab)]
Theorem: Int.even_xor'_odd'
File: Mathlib/Algebra/Ring/Int.lean

Proof steps:
state_before: m n✝ n : ℤ
⊢ ∃ k, Xor' (n = 2 * k) (n = 2 * k + 1)
state_after: case h
m n k : ℤ
⊢ Xor' (k + k = 2 * k) (k + k = 2 * k + 1)

case h
m n k : ℤ
⊢ Xor' (2 * k + 1 = 2 * k) (2 * k + 1 = 2 * k + 1)
tactic: rcases even_or_odd n with (⟨k, rfl⟩ | ⟨k, rfl⟩) <;> use k
Theorem: IsCompact.closedBall_div
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

Proof steps:
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x✝ y : E
hs : IsCompact s
hδ : 0 ≤ δ
x : E
⊢ closedBall x δ * s = x • cthickening δ s
state_after: no goals
tactic: simp [div_eq_mul_inv, hs.closedBall_mul hδ]
Theorem: MeasurableSpace.cardinal_generateMeasurable_le_continuum
File: Mathlib/MeasureTheory/MeasurableSpace/Card.lean

Proof steps:
state_before: α : Type u
s : Set (Set α)
hs : #↑s ≤ 𝔠
⊢ max (#↑s) 2 ^ ℵ₀ ≤ 𝔠
state_after: α : Type u
s : Set (Set α)
hs : #↑s ≤ 𝔠
⊢ max (#↑s) 2 ^ ℵ₀ ≤ 𝔠 ^ ℵ₀
tactic: rw [← continuum_power_aleph0]
state_before: α : Type u
s : Set (Set α)
hs : #↑s ≤ 𝔠
⊢ max (#↑s) 2 ^ ℵ₀ ≤ 𝔠 ^ ℵ₀
state_after: no goals
tactic: exact mod_cast power_le_power_right (max_le hs (nat_lt_continuum 2).le)
Theorem: Batteries.RBNode.balance1_All
File: .lake/packages/batteries/Batteries/Data/RBMap/WF.lean

Proof steps:
state_before: α : Type u_1
p : α → Prop
l : RBNode α
v : α
r : RBNode α
⊢ All p (l.balance1 v r) ↔ p v ∧ All p l ∧ All p r
state_after: α : Type u_1
p : α → Prop
l : RBNode α
v : α
r : RBNode α
⊢ All p
      (match l, v, r with
      | node red (node red a x b) y c, z, d => node red (node black a x b) y (node black c z d)
      | node red a x (node red b y c), z, d => node red (node black a x b) y (node black c z d)
      | a, x, b => node black a x b) ↔
    p v ∧ All p l ∧ All p r
tactic: unfold balance1
state_before: α : Type u_1
p : α → Prop
l : RBNode α
v : α
r : RBNode α
⊢ All p
      (match l, v, r with
      | node red (node red a x b) y c, z, d => node red (node black a x b) y (node black c z d)
      | node red a x (node red b y c), z, d => node red (node black a x b) y (node black c z d)
      | a, x, b => node black a x b) ↔
    p v ∧ All p l ∧ All p r
state_after: no goals
tactic: split <;> simp [and_assoc, and_left_comm]
Theorem: CategoryTheory.Limits.compYonedaSectionsEquiv_apply_app
File: Mathlib/CategoryTheory/Limits/Types.lean

Proof steps:
state_before: J : Type u_1
C : Type u_2
inst✝¹ : Category.{?u.98653, u_1} J
inst✝ : Category.{?u.99132, u_2} C
F : J ⥤ Cᵒᵖ
X : C
s : ↑(F ⋙ yoneda.obj X).sections
j j' : J
f : j ⟶ j'
⊢ ((const J).obj (op X)).map f ≫ (fun j => Quiver.Hom.op (↑s j)) j' = (fun j => Quiver.Hom.op (↑s j)) j ≫ F.map f
state_after: J : Type u_1
C : Type u_2
inst✝¹ : Category.{?u.98653, u_1} J
inst✝ : Category.{?u.99132, u_2} C
F : J ⥤ Cᵒᵖ
X : C
s : ↑(F ⋙ yoneda.obj X).sections
j j' : J
f : j ⟶ j'
⊢ 𝟙 (op X) ≫ (↑s j').op = (↑s j).op ≫ F.map f
tactic: dsimp
state_before: J : Type u_1
C : Type u_2
inst✝¹ : Category.{?u.98653, u_1} J
inst✝ : Category.{?u.99132, u_2} C
F : J ⥤ Cᵒᵖ
X : C
s : ↑(F ⋙ yoneda.obj X).sections
j j' : J
f : j ⟶ j'
⊢ 𝟙 (op X) ≫ (↑s j').op = (↑s j).op ≫ F.map f
state_after: J : Type u_1
C : Type u_2
inst✝¹ : Category.{?u.98653, u_1} J
inst✝ : Category.{?u.99132, u_2} C
F : J ⥤ Cᵒᵖ
X : C
s : ↑(F ⋙ yoneda.obj X).sections
j j' : J
f : j ⟶ j'
⊢ (↑s j').op = (↑s j).op ≫ F.map f
tactic: rw [Category.id_comp]
state_before: J : Type u_1
C : Type u_2
inst✝¹ : Category.{?u.98653, u_1} J
inst✝ : Category.{?u.99132, u_2} C
F : J ⥤ Cᵒᵖ
X : C
s : ↑(F ⋙ yoneda.obj X).sections
j j' : J
f : j ⟶ j'
⊢ (↑s j').op = (↑s j).op ≫ F.map f
state_after: no goals
tactic: exact Quiver.Hom.unop_inj (s.property f).symm
state_before: J : Type u_1
C : Type u_2
inst✝¹ : Category.{?u.98653, u_1} J
inst✝ : Category.{?u.99132, u_2} C
F : J ⥤ Cᵒᵖ
X : C
τ : (const J).obj (op X) ⟶ F
j j' : J
f : j ⟶ j'
⊢ Quiver.Hom.op ((F ⋙ yoneda.obj X).map f ((fun j => (τ.app j).unop) j)) = ((fun j => (τ.app j).unop) j').op
state_after: no goals
tactic: simpa using (τ.naturality f).symm
Theorem: RingCon.opOrderIso_symm_apply
File: Mathlib/RingTheory/Congruence/Opposite.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : Add R
inst✝ : Mul R
c d : RingCon R
⊢ { toFun := op, invFun := unop, left_inv := ⋯, right_inv := ⋯ } c ≤
      { toFun := op, invFun := unop, left_inv := ⋯, right_inv := ⋯ } d ↔
    c ≤ d
state_after: R : Type u_1
inst✝¹ : Add R
inst✝ : Mul R
c d : RingCon R
⊢ (∀ {x y : Rᵐᵒᵖ},
      ({ toFun := op, invFun := unop, left_inv := ⋯, right_inv := ⋯ } c) x y →
        ({ toFun := op, invFun := unop, left_inv := ⋯, right_inv := ⋯ } d) x y) ↔
    ∀ {x y : R}, c x y → d x y
tactic: rw [le_def, le_def]
state_before: R : Type u_1
inst✝¹ : Add R
inst✝ : Mul R
c d : RingCon R
⊢ (∀ {x y : Rᵐᵒᵖ},
      ({ toFun := op, invFun := unop, left_inv := ⋯, right_inv := ⋯ } c) x y →
        ({ toFun := op, invFun := unop, left_inv := ⋯, right_inv := ⋯ } d) x y) ↔
    ∀ {x y : R}, c x y → d x y
state_after: no goals
tactic: constructor <;> intro h _ _ h' <;> exact h h'