ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: ClosedEmbedding.closed_iff_preimage_closed
File: Mathlib/Topology/Maps/Basic.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
hf : ClosedEmbedding f
s : Set Y
hs : s ⊆ range f
⊢ IsClosed s ↔ IsClosed (f ⁻¹' s)
state_after: no goals
tactic: rw [hf.closed_iff_image_closed, image_preimage_eq_of_subset hs]
Theorem: padicNormE.norm_p_zpow
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℤ
⊢ ‖↑p ^ n‖ = ↑p ^ (-n)
state_after: no goals
tactic: rw [norm_zpow, norm_p, zpow_neg, inv_zpow]
Theorem: List.product_eq_productTR
File: .lake/packages/batteries/Batteries/Data/List/Basic.lean

Proof steps:
state_before: ⊢ @product = @productTR
state_after: case h.h.h.h
α : Type u_2
β : Type u_1
l₁ : List α
l₂ : List β
⊢ l₁.product l₂ = l₁.productTR l₂
tactic: funext α β l₁ l₂
state_before: case h.h.h.h
α : Type u_2
β : Type u_1
l₁ : List α
l₂ : List β
⊢ l₁.product l₂ = l₁.productTR l₂
state_after: case h.h.h.h
α : Type u_2
β : Type u_1
l₁ : List α
l₂ : List β
⊢ (l₁.bind fun a => map (Prod.mk a) l₂) = (foldl (fun acc a => foldl (fun acc b => acc.push (a, b)) acc l₂) #[] l₁).data
tactic: simp [product, productTR]
state_before: case h.h.h.h
α : Type u_2
β : Type u_1
l₁ : List α
l₂ : List β
⊢ (l₁.bind fun a => map (Prod.mk a) l₂) = (foldl (fun acc a => foldl (fun acc b => acc.push (a, b)) acc l₂) #[] l₁).data
state_after: case h.h.h.h
α : Type u_2
β : Type u_1
l₁ : List α
l₂ : List β
⊢ (l₁.bind fun a => map (Prod.mk a) l₂) = #[].data ++ l₁.bind ?h.h.h.h.G

case h.h.h.h.G
α : Type u_2
β : Type u_1
l₁ : List α
l₂ : List β
⊢ α → List (α × β)

case h.h.h.h.H
α : Type u_2
β : Type u_1
l₁ : List α
l₂ : List β
⊢ ∀ (acc : Array (α × β)) (a : α), (foldl (fun acc b => acc.push (a, b)) acc l₂).data = acc.data ++ ?h.h.h.h.G a
tactic: rw [Array.foldl_data_eq_bind]
state_before: case h.h.h.h
α : Type u_2
β : Type u_1
l₁ : List α
l₂ : List β
⊢ (l₁.bind fun a => map (Prod.mk a) l₂) = #[].data ++ l₁.bind ?h.h.h.h.G

case h.h.h.h.G
α : Type u_2
β : Type u_1
l₁ : List α
l₂ : List β
⊢ α → List (α × β)

case h.h.h.h.H
α : Type u_2
β : Type u_1
l₁ : List α
l₂ : List β
⊢ ∀ (acc : Array (α × β)) (a : α), (foldl (fun acc b => acc.push (a, b)) acc l₂).data = acc.data ++ ?h.h.h.h.G a
state_after: case h.h.h.h.H
α : Type u_2
β : Type u_1
l₁ : List α
l₂ : List β
⊢ ∀ (acc : Array (α × β)) (a : α), (foldl (fun acc b => acc.push (a, b)) acc l₂).data = acc.data ++ map (Prod.mk a) l₂
tactic: rfl
state_before: case h.h.h.h.H
α : Type u_2
β : Type u_1
l₁ : List α
l₂ : List β
⊢ ∀ (acc : Array (α × β)) (a : α), (foldl (fun acc b => acc.push (a, b)) acc l₂).data = acc.data ++ map (Prod.mk a) l₂
state_after: case h.h.h.h.H
α : Type u_2
β : Type u_1
l₁ : List α
l₂ : List β
acc✝ : Array (α × β)
a✝ : α
⊢ (foldl (fun acc b => acc.push (a✝, b)) acc✝ l₂).data = acc✝.data ++ map (Prod.mk a✝) l₂
tactic: intros
state_before: case h.h.h.h.H
α : Type u_2
β : Type u_1
l₁ : List α
l₂ : List β
acc✝ : Array (α × β)
a✝ : α
⊢ (foldl (fun acc b => acc.push (a✝, b)) acc✝ l₂).data = acc✝.data ++ map (Prod.mk a✝) l₂
state_after: no goals
tactic: apply Array.foldl_data_eq_map
Theorem: Submodule.dualAnnihilator_top
File: Mathlib/LinearAlgebra/Dual.lean

Proof steps:
state_before: R : Type u
M : Type v
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
W : Submodule R M
⊢ ⊤.dualAnnihilator = ⊥
state_after: R : Type u
M : Type v
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
W : Submodule R M
⊢ ⊤.dualAnnihilator ≤ ⊥
tactic: rw [eq_bot_iff]
state_before: R : Type u
M : Type v
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
W : Submodule R M
⊢ ⊤.dualAnnihilator ≤ ⊥
state_after: R : Type u
M : Type v
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
W : Submodule R M
v : Module.Dual R M
⊢ v ∈ ⊤.dualAnnihilator → v ∈ ⊥
tactic: intro v
state_before: R : Type u
M : Type v
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
W : Submodule R M
v : Module.Dual R M
⊢ v ∈ ⊤.dualAnnihilator → v ∈ ⊥
state_after: R : Type u
M : Type v
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
W : Submodule R M
v : Module.Dual R M
⊢ (∀ (w : M), v w = 0) → v = 0
tactic: simp_rw [mem_dualAnnihilator, mem_bot, mem_top, forall_true_left]
state_before: R : Type u
M : Type v
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
W : Submodule R M
v : Module.Dual R M
⊢ (∀ (w : M), v w = 0) → v = 0
state_after: no goals
tactic: exact fun h => LinearMap.ext h
Theorem: MeasureTheory.OuterMeasure.trim_mkMetric
File: Mathlib/MeasureTheory/Measure/Hausdorff.lean

Proof steps:
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝³ : EMetricSpace X
inst✝² : EMetricSpace Y
inst✝¹ : MeasurableSpace X
inst✝ : BorelSpace X
m : ℝ≥0∞ → ℝ≥0∞
⊢ (mkMetric m).trim = mkMetric m
state_after: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝³ : EMetricSpace X
inst✝² : EMetricSpace Y
inst✝¹ : MeasurableSpace X
inst✝ : BorelSpace X
m : ℝ≥0∞ → ℝ≥0∞
⊢ ⨆ i, (mkMetric'.pre (fun s => m (diam s)) (↑i)⁻¹).trim = ⨆ n, mkMetric'.pre (fun s => m (diam s)) (↑n)⁻¹
tactic: simp only [mkMetric, mkMetric'.eq_iSup_nat, trim_iSup]
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝³ : EMetricSpace X
inst✝² : EMetricSpace Y
inst✝¹ : MeasurableSpace X
inst✝ : BorelSpace X
m : ℝ≥0∞ → ℝ≥0∞
⊢ ⨆ i, (mkMetric'.pre (fun s => m (diam s)) (↑i)⁻¹).trim = ⨆ n, mkMetric'.pre (fun s => m (diam s)) (↑n)⁻¹
state_after: case e_s.h
ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝³ : EMetricSpace X
inst✝² : EMetricSpace Y
inst✝¹ : MeasurableSpace X
inst✝ : BorelSpace X
m : ℝ≥0∞ → ℝ≥0∞
n : ℕ
⊢ (mkMetric'.pre (fun s => m (diam s)) (↑n)⁻¹).trim = mkMetric'.pre (fun s => m (diam s)) (↑n)⁻¹
tactic: congr 1 with n : 1
state_before: case e_s.h
ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝³ : EMetricSpace X
inst✝² : EMetricSpace Y
inst✝¹ : MeasurableSpace X
inst✝ : BorelSpace X
m : ℝ≥0∞ → ℝ≥0∞
n : ℕ
⊢ (mkMetric'.pre (fun s => m (diam s)) (↑n)⁻¹).trim = mkMetric'.pre (fun s => m (diam s)) (↑n)⁻¹
state_after: case e_s.h
ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝³ : EMetricSpace X
inst✝² : EMetricSpace Y
inst✝¹ : MeasurableSpace X
inst✝ : BorelSpace X
m : ℝ≥0∞ → ℝ≥0∞
n : ℕ
s : Set X
⊢ m (diam (closure s)) = m (diam s)
tactic: refine mkMetric'.trim_pre _ (fun s => ?_) _
state_before: case e_s.h
ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝³ : EMetricSpace X
inst✝² : EMetricSpace Y
inst✝¹ : MeasurableSpace X
inst✝ : BorelSpace X
m : ℝ≥0∞ → ℝ≥0∞
n : ℕ
s : Set X
⊢ m (diam (closure s)) = m (diam s)
state_after: no goals
tactic: simp
Theorem: exists_vector_zero
File: Mathlib/Data/Vector3.lean

Proof steps:
state_before: α : Type u_1
m n : ℕ
f : Vector3 α 0 → Prop
x✝ : Exists f
v : Vector3 α 0
fv : f v
⊢ f []
state_after: α : Type u_1
m n : ℕ
f : Vector3 α 0 → Prop
x✝ : Exists f
v : Vector3 α 0
fv : f v
⊢ f v
tactic: rw [← eq_nil v]
state_before: α : Type u_1
m n : ℕ
f : Vector3 α 0 → Prop
x✝ : Exists f
v : Vector3 α 0
fv : f v
⊢ f v
state_after: no goals
tactic: exact fv
Theorem: mul_self_add_mul_self_eq_zero
File: Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
β : Type u_1
inst✝⁸ : Semiring α
inst✝⁷ : LinearOrder α
a b c d : α
inst✝⁶ : IsRightCancelAdd α
inst✝⁵ : NoZeroDivisors α
inst✝⁴ : ZeroLEOneClass α
inst✝³ : ExistsAddOfLE α
inst✝² : PosMulMono α
inst✝¹ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1
⊢ a * a + b * b = 0 ↔ a = 0 ∧ b = 0
state_after: no goals
tactic: rw [add_eq_zero_iff', mul_self_eq_zero (M₀ := α), mul_self_eq_zero (M₀ := α)] <;>
    apply mul_self_nonneg
Theorem: Real.strictMonoOn_tan
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

Proof steps:
state_before: ⊢ StrictMonoOn tan (Ioo (-(π / 2)) (π / 2))
state_after: x : ℝ
hx : x ∈ Ioo (-(π / 2)) (π / 2)
y : ℝ
hy : y ∈ Ioo (-(π / 2)) (π / 2)
hlt : x < y
⊢ tan x < tan y
tactic: rintro x hx y hy hlt
state_before: x : ℝ
hx : x ∈ Ioo (-(π / 2)) (π / 2)
y : ℝ
hy : y ∈ Ioo (-(π / 2)) (π / 2)
hlt : x < y
⊢ tan x < tan y
state_after: x : ℝ
hx : x ∈ Ioo (-(π / 2)) (π / 2)
y : ℝ
hy : y ∈ Ioo (-(π / 2)) (π / 2)
hlt : x < y
⊢ 0 < sin (y - x)
tactic: rw [tan_eq_sin_div_cos, tan_eq_sin_div_cos,
    div_lt_div_iff (cos_pos_of_mem_Ioo hx) (cos_pos_of_mem_Ioo hy), mul_comm, ← sub_pos, ← sin_sub]
state_before: x : ℝ
hx : x ∈ Ioo (-(π / 2)) (π / 2)
y : ℝ
hy : y ∈ Ioo (-(π / 2)) (π / 2)
hlt : x < y
⊢ 0 < sin (y - x)
state_after: no goals
tactic: exact sin_pos_of_pos_of_lt_pi (sub_pos.2 hlt) <| by linarith [hx.1, hy.2]
Theorem: eq_one_of_mul_right
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
inst✝¹ : CommMonoid α
inst✝ : Subsingleton αˣ
a b : α
h : a * b = 1
⊢ b * a = 1
state_after: no goals
tactic: rwa [mul_comm]
Theorem: completedRiemannZeta_one_sub
File: Mathlib/NumberTheory/LSeries/RiemannZeta.lean

Proof steps:
state_before: s : ℂ
⊢ completedRiemannZeta (1 - s) = completedRiemannZeta s
state_after: no goals
tactic: rw [← completedHurwitzZetaEven_zero, ← completedCosZeta_zero, completedHurwitzZetaEven_one_sub]
Theorem: TruncatedWittVector.ext_iff
File: Mathlib/RingTheory/WittVector/Truncated.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
x y : TruncatedWittVector p n R
h : x = y
i : Fin n
⊢ coeff i x = coeff i y
state_after: no goals
tactic: rw [h]
Theorem: CategoryTheory.InjectiveResolution.homotopyEquiv_inv_ι
File: Mathlib/CategoryTheory/Abelian/InjectiveResolution.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
X : C
I J : InjectiveResolution X
⊢ J.ι ≫ (I.homotopyEquiv J).inv = I.ι
state_after: no goals
tactic: simp [homotopyEquiv]
Theorem: Wbtw.angle₃₁₂_eq_zero_of_ne
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.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
p p₀ p₁✝ p₂✝ p₁ p₂ p₃ : P
h : Wbtw ℝ p₁ p₂ p₃
hp₂p₁ : p₂ ≠ p₁
⊢ ∠ p₃ p₁ p₂ = 0
state_after: no goals
tactic: rw [← h.angle₂₁₃_eq_zero_of_ne hp₂p₁, angle_comm]
Theorem: List.set_eq_take_cons_drop
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α : Type u_1
a : α
n : Nat
l : List α
h : n < l.length
⊢ l.set n a = take n l ++ a :: drop (n + 1) l
state_after: no goals
tactic: rw [set_eq_modifyNth, modifyNth_eq_take_cons_drop _ h]
Theorem: Fin.foldr_loop
File: .lake/packages/batteries/Batteries/Data/Fin/Lemmas.lean

Proof steps:
state_before: n : Nat
α : Sort u_1
m : Nat
f : Fin (n + 1) → α → α
x : α
h : m + 1 ≤ n + 1
⊢ foldr.loop (n + 1) f ⟨m + 1, h⟩ x = f 0 (foldr.loop n (fun i => f i.succ) ⟨m, ⋯⟩ x)
state_after: no goals
tactic: induction m generalizing x with
  | zero => simp [foldr_loop_zero, foldr_loop_succ]
  | succ m ih => rw [foldr_loop_succ, ih, foldr_loop_succ, Fin.succ]
Theorem: Matrix.zero_zpow
File: Mathlib/LinearAlgebra/Matrix/ZPow.lean

Proof steps:
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
n : ℕ
h : ↑n ≠ 0
⊢ 0 ^ ↑n = 0
state_after: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
n : ℕ
h : ↑n ≠ 0
⊢ n ≠ 0
tactic: rw [zpow_natCast, zero_pow]
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
n : ℕ
h : ↑n ≠ 0
⊢ n ≠ 0
state_after: no goals
tactic: exact mod_cast h
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
n : ℕ
x✝ : -[n+1] ≠ 0
⊢ 0 ^ -[n+1] = 0
state_after: no goals
tactic: simp [zero_pow n.succ_ne_zero]
Theorem: SameRay.sameRay_nonneg_smul_right
File: Mathlib/LinearAlgebra/Ray.lean

Proof steps:
state_before: R : Type u_1
inst✝¹⁰ : StrictOrderedCommSemiring R
M : Type u_2
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
N : Type u_3
inst✝⁷ : AddCommMonoid N
inst✝⁶ : Module R N
ι : Type u_4
inst✝⁵ : DecidableEq ι
x y z : M
S : Type u_5
inst✝⁴ : OrderedCommSemiring S
inst✝³ : Algebra S R
inst✝² : Module S M
inst✝¹ : SMulPosMono S R
inst✝ : IsScalarTower S R M
a : S
v : M
h : 0 ≤ a
⊢ SameRay R v (a • v)
state_after: case inl
R : Type u_1
inst✝¹⁰ : StrictOrderedCommSemiring R
M : Type u_2
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
N : Type u_3
inst✝⁷ : AddCommMonoid N
inst✝⁶ : Module R N
ι : Type u_4
inst✝⁵ : DecidableEq ι
x y z : M
S : Type u_5
inst✝⁴ : OrderedCommSemiring S
inst✝³ : Algebra S R
inst✝² : Module S M
inst✝¹ : SMulPosMono S R
inst✝ : IsScalarTower S R M
a : S
v : M
h✝ : 0 ≤ a
h : (algebraMap S R) a = 0
⊢ SameRay R v (a • v)

case inr
R : Type u_1
inst✝¹⁰ : StrictOrderedCommSemiring R
M : Type u_2
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
N : Type u_3
inst✝⁷ : AddCommMonoid N
inst✝⁶ : Module R N
ι : Type u_4
inst✝⁵ : DecidableEq ι
x y z : M
S : Type u_5
inst✝⁴ : OrderedCommSemiring S
inst✝³ : Algebra S R
inst✝² : Module S M
inst✝¹ : SMulPosMono S R
inst✝ : IsScalarTower S R M
a : S
v : M
h✝ : 0 ≤ a
h : 0 < (algebraMap S R) a
⊢ SameRay R v (a • v)
tactic: obtain h | h := (algebraMap_nonneg R h).eq_or_gt
Theorem: eq_iff_atom_le_iff
File: Mathlib/Order/Atoms.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝¹ : CompleteLattice α
inst✝ : IsAtomistic α
a b : α
⊢ a = b ↔ ∀ (c : α), IsAtom c → (c ≤ a ↔ c ≤ b)
state_after: ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝¹ : CompleteLattice α
inst✝ : IsAtomistic α
a b : α
h : ∀ (c : α), IsAtom c → (c ≤ a ↔ c ≤ b)
⊢ a = b
tactic: refine ⟨fun h => h ▸ by simp, fun h => ?_⟩
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝¹ : CompleteLattice α
inst✝ : IsAtomistic α
a b : α
h : ∀ (c : α), IsAtom c → (c ≤ a ↔ c ≤ b)
⊢ a = b
state_after: no goals
tactic: exact le_antisymm (le_iff_atom_le_imp.2 fun a ha hx => (h a ha).1 hx)
    (le_iff_atom_le_imp.2 fun a ha hy => (h a ha).2 hy)
Theorem: norm_of_subsingleton
File: Mathlib/Analysis/Normed/Group/Basic.lean

Proof steps:
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝³ : SeminormedGroup E
inst✝² : SeminormedGroup F
inst✝¹ : SeminormedGroup G
s : Set E
a✝ a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
inst✝ : Subsingleton E
a : E
⊢ ‖a‖ = 0
state_after: no goals
tactic: rw [Subsingleton.elim a 1, norm_one']
Theorem: Part.append_get_eq
File: Mathlib/Data/Part.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Append α
a b : Part α
hab : (a ++ b).Dom
⊢ (a ++ b).get hab = a.get ⋯ ++ b.get ⋯
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Append α
a b : Part α
hab : (a ++ b).Dom
⊢ (a.bind fun y => map (fun x => y ++ x) b).get ⋯ = a.get ⋯ ++ b.get ⋯
tactic: simp [append_def]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Append α
a b : Part α
hab : (a ++ b).Dom
⊢ (a.bind fun y => map (fun x => y ++ x) b).get ⋯ = a.get ⋯ ++ b.get ⋯
state_after: no goals
tactic: aesop
Theorem: Holor.sum_unitVec_mul_slice
File: Mathlib/Data/Holor.lean

Proof steps:
state_before: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
x : Holor α (d :: ds)
⊢ ∑ i ∈ (Finset.range d).attach, unitVec d ↑i ⊗ x.slice ↑i ⋯ = x
state_after: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
x : Holor α (d :: ds)
⊢ (∑ i ∈ (Finset.range d).attach, unitVec d ↑i ⊗ x.slice ↑i ⋯).slice = x.slice
tactic: apply slice_eq _ _ _
state_before: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
x : Holor α (d :: ds)
⊢ (∑ i ∈ (Finset.range d).attach, unitVec d ↑i ⊗ x.slice ↑i ⋯).slice = x.slice
state_after: case h.h
α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
x : Holor α (d :: ds)
i : ℕ
hid : i < d
⊢ (∑ i ∈ (Finset.range d).attach, unitVec d ↑i ⊗ x.slice ↑i ⋯).slice i hid = x.slice i hid
tactic: ext i hid
state_before: case h.h
α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
x : Holor α (d :: ds)
i : ℕ
hid : i < d
⊢ (∑ i ∈ (Finset.range d).attach, unitVec d ↑i ⊗ x.slice ↑i ⋯).slice i hid = x.slice i hid
state_after: case h.h
α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
x : Holor α (d :: ds)
i : ℕ
hid : i < d
⊢ ∑ x_1 ∈ (Finset.range d).attach, (unitVec d ↑x_1 ⊗ x.slice ↑x_1 ⋯).slice i hid = x.slice i hid
tactic: rw [← slice_sum]
state_before: case h.h
α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
x : Holor α (d :: ds)
i : ℕ
hid : i < d
⊢ ∑ x_1 ∈ (Finset.range d).attach, (unitVec d ↑x_1 ⊗ x.slice ↑x_1 ⋯).slice i hid = x.slice i hid
state_after: case h.h
α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
x : Holor α (d :: ds)
i : ℕ
hid : i < d
⊢ (∑ x_1 ∈ (Finset.range d).attach, if i = ↑x_1 then x.slice ↑x_1 ⋯ else 0) = x.slice i hid
tactic: simp only [slice_unitVec_mul hid]
state_before: case h.h
α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
x : Holor α (d :: ds)
i : ℕ
hid : i < d
⊢ (∑ x_1 ∈ (Finset.range d).attach, if i = ↑x_1 then x.slice ↑x_1 ⋯ else 0) = x.slice i hid
state_after: case h.h
α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
x : Holor α (d :: ds)
i : ℕ
hid : i < d
⊢ (if i = ↑⟨i, ⋯⟩ then x.slice ↑⟨i, ⋯⟩ ⋯ else 0) = x.slice i hid

case h.h.h₀
α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
x : Holor α (d :: ds)
i : ℕ
hid : i < d
⊢ ∀ b ∈ (Finset.range d).attach, b ≠ ⟨i, ⋯⟩ → (if i = ↑b then x.slice ↑b ⋯ else 0) = 0

case h.h.h₁
α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
x : Holor α (d :: ds)
i : ℕ
hid : i < d
⊢ ⟨i, ⋯⟩ ∉ (Finset.range d).attach → (if i = ↑⟨i, ⋯⟩ then x.slice ↑⟨i, ⋯⟩ ⋯ else 0) = 0
tactic: rw [Finset.sum_eq_single (Subtype.mk i <| Finset.mem_range.2 hid)]
Theorem: tendsto_nat_ceil_div_atTop
File: Mathlib/Analysis/SpecificLimits/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
R : Type u_4
inst✝³ : TopologicalSpace R
inst✝² : LinearOrderedField R
inst✝¹ : OrderTopology R
inst✝ : FloorRing R
⊢ Tendsto (fun x => ↑⌈x⌉₊ / x) atTop (𝓝 1)
state_after: no goals
tactic: simpa using tendsto_nat_ceil_mul_div_atTop (zero_le_one' R)
Theorem: List.nodup_join
File: Mathlib/Data/List/Nodup.lean

Proof steps:
state_before: α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a b : α
L : List (List α)
⊢ L.join.Nodup ↔ (∀ l ∈ L, l.Nodup) ∧ Pairwise Disjoint L
state_after: no goals
tactic: simp only [Nodup, pairwise_join, disjoint_left.symm, forall_mem_ne]
Theorem: Finset.coe_cons
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s✝ t : Finset α
a✝ b a : α
s : Finset α
h : a ∉ s
⊢ ↑(cons a s h) = insert a ↑s
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
s✝ t : Finset α
a✝ b a : α
s : Finset α
h : a ∉ s
x✝ : α
⊢ x✝ ∈ ↑(cons a s h) ↔ x✝ ∈ insert a ↑s
tactic: ext
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
s✝ t : Finset α
a✝ b a : α
s : Finset α
h : a ∉ s
x✝ : α
⊢ x✝ ∈ ↑(cons a s h) ↔ x✝ ∈ insert a ↑s
state_after: no goals
tactic: simp
Theorem: EuclideanGeometry.circumsphere_eq_of_cospherical
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
ps : Set P
n : ℕ
inst✝ : FiniteDimensional ℝ V
hd : finrank ℝ V = 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
ps : Set P
n : ℕ
inst✝ : FiniteDimensional ℝ V
hd : finrank ℝ V = 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 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
ps : Set P
n : ℕ
inst✝ : FiniteDimensional ℝ V
hd : finrank ℝ V = 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: PreconnectedSpace.trivial_of_discrete
File: Mathlib/Topology/Separation.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : PreconnectedSpace X
inst✝ : DiscreteTopology X
⊢ Subsingleton X
state_after: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : PreconnectedSpace X
inst✝ : DiscreteTopology X
⊢ ¬Nontrivial X
tactic: rw [← not_nontrivial_iff_subsingleton]
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : PreconnectedSpace X
inst✝ : DiscreteTopology X
⊢ ¬Nontrivial X
state_after: case mk.intro.intro
X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : PreconnectedSpace X
inst✝ : DiscreteTopology X
x y : X
hxy : x ≠ y
⊢ False
tactic: rintro ⟨x, y, hxy⟩
state_before: case mk.intro.intro
X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : PreconnectedSpace X
inst✝ : DiscreteTopology X
x y : X
hxy : x ≠ y
⊢ False
state_after: case mk.intro.intro
X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : PreconnectedSpace X
inst✝ : DiscreteTopology X
x y : X
hxy : x ∉ univ
⊢ False
tactic: rw [Ne, ← mem_singleton_iff, (isClopen_discrete _).eq_univ <| singleton_nonempty y] at hxy
state_before: case mk.intro.intro
X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : PreconnectedSpace X
inst✝ : DiscreteTopology X
x y : X
hxy : x ∉ univ
⊢ False
state_after: no goals
tactic: exact hxy (mem_univ x)
Theorem: measurable_find
File: Mathlib/MeasureTheory/MeasurableSpace/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
inst✝¹ : MeasurableSpace α
p : α → ℕ → Prop
inst✝ : (x : α) → DecidablePred (p x)
hp : ∀ (x : α), ∃ N, p x N
hm : ∀ (k : ℕ), MeasurableSet {x | p x k}
⊢ Measurable fun x => Nat.find ⋯
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
inst✝¹ : MeasurableSpace α
p : α → ℕ → Prop
inst✝ : (x : α) → DecidablePred (p x)
hp : ∀ (x : α), ∃ N, p x N
hm : ∀ (k : ℕ), MeasurableSet {x | p x k}
x : α
⊢ MeasurableSet ((fun x => Nat.find ⋯) ⁻¹' {Nat.find ⋯})
tactic: refine measurable_to_nat fun x => ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
inst✝¹ : MeasurableSpace α
p : α → ℕ → Prop
inst✝ : (x : α) → DecidablePred (p x)
hp : ∀ (x : α), ∃ N, p x N
hm : ∀ (k : ℕ), MeasurableSet {x | p x k}
x : α
⊢ MeasurableSet ((fun x => Nat.find ⋯) ⁻¹' {Nat.find ⋯})
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
inst✝¹ : MeasurableSpace α
p : α → ℕ → Prop
inst✝ : (x : α) → DecidablePred (p x)
hp : ∀ (x : α), ∃ N, p x N
hm : ∀ (k : ℕ), MeasurableSet {x | p x k}
x : α
⊢ MeasurableSet (disjointed (fun k => {x | p x k}) (Nat.find ⋯))
tactic: rw [preimage_find_eq_disjointed (fun k => {x | p x k})]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
inst✝¹ : MeasurableSpace α
p : α → ℕ → Prop
inst✝ : (x : α) → DecidablePred (p x)
hp : ∀ (x : α), ∃ N, p x N
hm : ∀ (k : ℕ), MeasurableSet {x | p x k}
x : α
⊢ MeasurableSet (disjointed (fun k => {x | p x k}) (Nat.find ⋯))
state_after: no goals
tactic: exact MeasurableSet.disjointed hm _