1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: AffineIndependent.not_mem_affineSpan_diff
File: Mathlib/LinearAlgebra/AffineSpace/Independent.lean

tactic: simp [ha]
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✝ : Nontrivial k
p : ι → P
ha : AffineIndependent k p
i : ι
s : Set ι
⊢ p i ∉ affineSpan k (p '' (s \ {i}))
state_after: no goals
Theorem: IsClosed.nhdsSet_le_sup'
File: Mathlib/Topology/NhdsSet.lean

tactic: rw [Set.inter_comm]
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f : Filter X
s t s₁ s₂ t₁ t₂ : Set X
x : X
h : IsClosed t
⊢ 𝓝ˢ s ≤ 𝓝ˢ (t ∩ s) ⊔ 𝓟 tᶜ
state_after: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f : Filter X
s t s₁ s₂ t₁ t₂ : Set X
x : X
h : IsClosed t
⊢ 𝓝ˢ s ≤ 𝓝ˢ (s ∩ t) ⊔ 𝓟 tᶜ

tactic: exact h.nhdsSet_le_sup s
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f : Filter X
s t s₁ s₂ t₁ t₂ : Set X
x : X
h : IsClosed t
⊢ 𝓝ˢ s ≤ 𝓝ˢ (s ∩ t) ⊔ 𝓟 tᶜ
state_after: no goals
Theorem: DifferentiableAt.hasFDerivAt
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

tactic: dsimp only [DifferentiableAt] at h
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
h : DifferentiableAt 𝕜 f x
⊢ HasFDerivAt f (fderiv 𝕜 f x) x
state_after: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
h : ∃ f', HasFDerivAt f f' x
⊢ HasFDerivAt f (fderiv 𝕜 f x) x

tactic: rw [fderiv, dif_pos h]
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
h : ∃ f', HasFDerivAt f f' x
⊢ HasFDerivAt f (fderiv 𝕜 f x) x
state_after: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
h : ∃ f', HasFDerivAt f f' x
⊢ HasFDerivAt f (Classical.choose h) x

tactic: exact Classical.choose_spec h
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
h : ∃ f', HasFDerivAt f f' x
⊢ HasFDerivAt f (Classical.choose h) x
state_after: no goals
Theorem: himp_idem
File: Mathlib/Order/Heyting/Basic.lean

tactic: rw [himp_himp, inf_idem]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : GeneralizedHeytingAlgebra α
a b c d : α
⊢ b ⇨ b ⇨ a = b ⇨ a
state_after: no goals
Theorem: Real.sin_sq_add_cos_sq
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [sin_sq_add_cos_sq]
state_before: x y : ℝ
⊢ ↑(sin x ^ 2 + cos x ^ 2) = ↑1
state_after: no goals
Theorem: String.Iterator.ValidFor.extract
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

tactic: cases h₁.out
state_before: l m r : List Char
it₁ it₂ : Iterator
h₁ : ValidFor l (m ++ r) it₁
h₂ : ValidFor (m.reverse ++ l) r it₂
⊢ it₁.extract it₂ = { data := m }
state_after: case refl
l m r : List Char
it₂ : Iterator
h₂ : ValidFor (m.reverse ++ l) r it₂
h₁ : ValidFor l (m ++ r) { s := { data := l.reverseAux (m ++ r) }, i := { byteIdx := utf8Len l } }
⊢ { s := { data := l.reverseAux (m ++ r) }, i := { byteIdx := utf8Len l } }.extract it₂ = { data := m }

tactic: cases h₂.out
state_before: case refl
l m r : List Char
it₂ : Iterator
h₂ : ValidFor (m.reverse ++ l) r it₂
h₁ : ValidFor l (m ++ r) { s := { data := l.reverseAux (m ++ r) }, i := { byteIdx := utf8Len l } }
⊢ { s := { data := l.reverseAux (m ++ r) }, i := { byteIdx := utf8Len l } }.extract it₂ = { data := m }
state_after: case refl.refl
l m r : List Char
h₁ : ValidFor l (m ++ r) { s := { data := l.reverseAux (m ++ r) }, i := { byteIdx := utf8Len l } }
h₂ :
  ValidFor (m.reverse ++ l) r
    { s := { data := (m.reverse ++ l).reverseAux r }, i := { byteIdx := utf8Len (m.reverse ++ l) } }
⊢ { s := { data := l.reverseAux (m ++ r) }, i := { byteIdx := utf8Len l } }.extract
      { s := { data := (m.reverse ++ l).reverseAux r }, i := { byteIdx := utf8Len (m.reverse ++ l) } } =
    { data := m }

tactic: simp only [Iterator.extract, List.reverseAux_eq, List.reverse_append, List.reverse_reverse,
  List.append_assoc, ne_eq, not_true_eq_false, decide_False, utf8Len_append, utf8Len_reverse,
  gt_iff_lt, pos_lt_eq, Nat.not_lt.2 (Nat.le_add_left ..), Bool.or_self, Bool.false_eq_true,
  ↓reduceIte]
state_before: case refl.refl
l m r : List Char
h₁ : ValidFor l (m ++ r) { s := { data := l.reverseAux (m ++ r) }, i := { byteIdx := utf8Len l } }
h₂ :
  ValidFor (m.reverse ++ l) r
    { s := { data := (m.reverse ++ l).reverseAux r }, i := { byteIdx := utf8Len (m.reverse ++ l) } }
⊢ { s := { data := l.reverseAux (m ++ r) }, i := { byteIdx := utf8Len l } }.extract
      { s := { data := (m.reverse ++ l).reverseAux r }, i := { byteIdx := utf8Len (m.reverse ++ l) } } =
    { data := m }
state_after: case refl.refl
l m r : List Char
h₁ : ValidFor l (m ++ r) { s := { data := l.reverseAux (m ++ r) }, i := { byteIdx := utf8Len l } }
h₂ :
  ValidFor (m.reverse ++ l) r
    { s := { data := (m.reverse ++ l).reverseAux r }, i := { byteIdx := utf8Len (m.reverse ++ l) } }
⊢ { data := l.reverse ++ (m ++ r) }.extract { byteIdx := utf8Len l } { byteIdx := utf8Len m + utf8Len l } =
    { data := m }

tactic: simpa [Nat.add_comm] using extract_of_valid l.reverse m r
state_before: case refl.refl
l m r : List Char
h₁ : ValidFor l (m ++ r) { s := { data := l.reverseAux (m ++ r) }, i := { byteIdx := utf8Len l } }
h₂ :
  ValidFor (m.reverse ++ l) r
    { s := { data := (m.reverse ++ l).reverseAux r }, i := { byteIdx := utf8Len (m.reverse ++ l) } }
⊢ { data := l.reverse ++ (m ++ r) }.extract { byteIdx := utf8Len l } { byteIdx := utf8Len m + utf8Len l } =
    { data := m }
state_after: no goals
Theorem: MvQPF.supp_map
File: Mathlib/Data/QPF/Multivariate/Basic.lean

tactic: rw [← abs_repr x]
state_before: n : ℕ
F : TypeVec.{u} n → Type u_1
q : MvQPF F
h : IsUniform
α β : TypeVec.{u} n
g : α ⟹ β
x : F α
i : Fin2 n
⊢ supp (g <$$> x) i = g i '' supp x i
state_after: n : ℕ
F : TypeVec.{u} n → Type u_1
q : MvQPF F
h : IsUniform
α β : TypeVec.{u} n
g : α ⟹ β
x : F α
i : Fin2 n
⊢ supp (g <$$> abs (repr x)) i = g i '' supp (abs (repr x)) i

tactic: cases' repr x with a f
state_before: n : ℕ
F : TypeVec.{u} n → Type u_1
q : MvQPF F
h : IsUniform
α β : TypeVec.{u} n
g : α ⟹ β
x : F α
i : Fin2 n
⊢ supp (g <$$> abs (repr x)) i = g i '' supp (abs (repr x)) i
state_after: case mk
n : ℕ
F : TypeVec.{u} n → Type u_1
q : MvQPF F
h : IsUniform
α β : TypeVec.{u} n
g : α ⟹ β
x : F α
i : Fin2 n
a : (P F).A
f : (P F).B a ⟹ α
⊢ supp (g <$$> abs ⟨a, f⟩) i = g i '' supp (abs ⟨a, f⟩) i

tactic: rw [← abs_map, MvPFunctor.map_eq]
state_before: case mk
n : ℕ
F : TypeVec.{u} n → Type u_1
q : MvQPF F
h : IsUniform
α β : TypeVec.{u} n
g : α ⟹ β
x : F α
i : Fin2 n
a : (P F).A
f : (P F).B a ⟹ α
⊢ supp (g <$$> abs ⟨a, f⟩) i = g i '' supp (abs ⟨a, f⟩) i
state_after: case mk
n : ℕ
F : TypeVec.{u} n → Type u_1
q : MvQPF F
h : IsUniform
α β : TypeVec.{u} n
g : α ⟹ β
x : F α
i : Fin2 n
a : (P F).A
f : (P F).B a ⟹ α
⊢ supp (abs ⟨a, g ⊚ f⟩) i = g i '' supp (abs ⟨a, f⟩) i

tactic: rw [supp_eq_of_isUniform h, supp_eq_of_isUniform h, ← image_comp]
state_before: case mk
n : ℕ
F : TypeVec.{u} n → Type u_1
q : MvQPF F
h : IsUniform
α β : TypeVec.{u} n
g : α ⟹ β
x : F α
i : Fin2 n
a : (P F).A
f : (P F).B a ⟹ α
⊢ supp (abs ⟨a, g ⊚ f⟩) i = g i '' supp (abs ⟨a, f⟩) i
state_after: case mk
n : ℕ
F : TypeVec.{u} n → Type u_1
q : MvQPF F
h : IsUniform
α β : TypeVec.{u} n
g : α ⟹ β
x : F α
i : Fin2 n
a : (P F).A
f : (P F).B a ⟹ α
⊢ (g ⊚ f) i '' univ = g i ∘ f i '' univ

tactic: rfl
state_before: case mk
n : ℕ
F : TypeVec.{u} n → Type u_1
q : MvQPF F
h : IsUniform
α β : TypeVec.{u} n
g : α ⟹ β
x : F α
i : Fin2 n
a : (P F).A
f : (P F).B a ⟹ α
⊢ (g ⊚ f) i '' univ = g i ∘ f i '' univ
state_after: no goals
Theorem: Set.image_union
File: Mathlib/Data/Set/Image.lean

tactic: rintro ⟨a, h | h, rfl⟩ <;> [left; right] <;> exact ⟨_, h, rfl⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
s✝ t✝ : Set α
f : α → β
s t : Set α
x : β
⊢ x ∈ f '' (s ∪ t) → x ∈ f '' s ∪ f '' t
state_after: no goals

tactic: rintro (⟨a, h, rfl⟩ | ⟨a, h, rfl⟩) <;> refine ⟨_, ?_, rfl⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
s✝ t✝ : Set α
f : α → β
s t : Set α
x : β
⊢ x ∈ f '' s ∪ f '' t → x ∈ f '' (s ∪ t)
state_after: case inl.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
s✝ t✝ : Set α
f : α → β
s t : Set α
a : α
h : a ∈ s
⊢ a ∈ s ∪ t

case inr.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
s✝ t✝ : Set α
f : α → β
s t : Set α
a : α
h : a ∈ t
⊢ a ∈ s ∪ t

tactic: exact mem_union_left t h
state_before: case inl.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
s✝ t✝ : Set α
f : α → β
s t : Set α
a : α
h : a ∈ s
⊢ a ∈ s ∪ t
state_after: no goals

tactic: exact mem_union_right s h
state_before: case inr.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
s✝ t✝ : Set α
f : α → β
s t : Set α
a : α
h : a ∈ t
⊢ a ∈ s ∪ t
state_after: no goals
Theorem: units_ne_neg_self
File: Mathlib/Algebra/CharZero/Lemmas.lean

tactic: simp_rw [ne_eq, Units.ext_iff, Units.val_neg, eq_neg_iff_add_eq_zero, ← two_mul,
  Units.mul_left_eq_zero, two_ne_zero, not_false_iff]
state_before: R : Type u_1
inst✝¹ : Ring R
inst✝ : CharZero R
u : Rˣ
⊢ u ≠ -u
state_after: no goals
Theorem: ContinuousLinearMap.projKerOfRightInverse_comp_inv
File: Mathlib/Topology/Algebra/Module/Basic.lean

tactic: simp [h y]
state_before: R : Type u_1
inst✝¹⁵ : Ring R
R₂ : Type u_2
inst✝¹⁴ : Ring R₂
R₃ : Type u_3
inst✝¹³ : Ring R₃
M : Type u_4
inst✝¹² : TopologicalSpace M
inst✝¹¹ : AddCommGroup M
M₂ : Type u_5
inst✝¹⁰ : TopologicalSpace M₂
inst✝⁹ : AddCommGroup M₂
M₃ : Type u_6
inst✝⁸ : TopologicalSpace M₃
inst✝⁷ : AddCommGroup M₃
M₄ : Type u_7
inst✝⁶ : TopologicalSpace M₄
inst✝⁵ : AddCommGroup M₄
inst✝⁴ : Module R M
inst✝³ : Module R₂ M₂
inst✝² : Module R₃ M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
σ₂₁ : R₂ →+* R
inst✝¹ : RingHomInvPair σ₁₂ σ₂₁
inst✝ : TopologicalAddGroup M
f₁ : M →SL[σ₁₂] M₂
f₂ : M₂ →SL[σ₂₁] M
h : Function.RightInverse ⇑f₂ ⇑f₁
y : M₂
⊢ ↑((f₁.projKerOfRightInverse f₂ h) (f₂ y)) = ↑0
state_after: no goals
Theorem: MeasureTheory.ae_lt_top'
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: rwa [← lintegral_congr_ae hf.ae_eq_mk]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : AEMeasurable f μ
h2f : ∫⁻ (x : α), f x ∂μ ≠ ⊤
⊢ ∫⁻ (x : α), AEMeasurable.mk f hf x ∂μ ≠ ⊤
state_after: no goals

tactic: rwa [hx]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : AEMeasurable f μ
h2f : ∫⁻ (x : α), f x ∂μ ≠ ⊤
h2f_meas : ∫⁻ (x : α), AEMeasurable.mk f hf x ∂μ ≠ ⊤
x : α
hx : f x = AEMeasurable.mk f hf x
h : AEMeasurable.mk f hf x < ⊤
⊢ f x < ⊤
state_after: no goals
Theorem: associated_unit_mul_left
File: Mathlib/Algebra/Associated.lean

tactic: rw [mul_comm]
state_before: α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
β : Type u_5
inst✝ : CommMonoid β
a u : β
hu : IsUnit u
⊢ u * a ~ᵤ a
state_after: α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
β : Type u_5
inst✝ : CommMonoid β
a u : β
hu : IsUnit u
⊢ a * u ~ᵤ a

tactic: exact associated_mul_unit_left _ _ hu
state_before: α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
β : Type u_5
inst✝ : CommMonoid β
a u : β
hu : IsUnit u
⊢ a * u ~ᵤ a
state_after: no goals
Theorem: Matrix.dotProduct_zero
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp [dotProduct]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : Fintype m
inst✝¹ : Fintype n
inst✝ : NonUnitalNonAssocSemiring α
u v w : m → α
x y : n → α
⊢ v ⬝ᵥ 0 = 0
state_after: no goals
Theorem: Cardinal.eq_aleph_of_eq_card_ord
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: cases' eq_aleph'_of_eq_card_ord ho with a ha
state_before: o : Ordinal.{u_1}
ho : o.card.ord = o
ho' : ω ≤ o
⊢ ∃ a, (aleph a).ord = o
state_after: case intro
o : Ordinal.{u_1}
ho : o.card.ord = o
ho' : ω ≤ o
a : Ordinal.{u_1}
ha : (aleph' a).ord = o
⊢ ∃ a, (aleph a).ord = o

tactic: use a - ω
state_before: case intro
o : Ordinal.{u_1}
ho : o.card.ord = o
ho' : ω ≤ o
a : Ordinal.{u_1}
ha : (aleph' a).ord = o
⊢ ∃ a, (aleph a).ord = o
state_after: case h
o : Ordinal.{u_1}
ho : o.card.ord = o
ho' : ω ≤ o
a : Ordinal.{u_1}
ha : (aleph' a).ord = o
⊢ (aleph (a - ω)).ord = o

tactic: unfold aleph
state_before: case h
o : Ordinal.{u_1}
ho : o.card.ord = o
ho' : ω ≤ o
a : Ordinal.{u_1}
ha : (aleph' a).ord = o
⊢ (aleph (a - ω)).ord = o
state_after: case h
o : Ordinal.{u_1}
ho : o.card.ord = o
ho' : ω ≤ o
a : Ordinal.{u_1}
ha : (aleph' a).ord = o
⊢ (aleph' (ω + (a - ω))).ord = o

tactic: rwa [Ordinal.add_sub_cancel_of_le]
state_before: case h
o : Ordinal.{u_1}
ho : o.card.ord = o
ho' : ω ≤ o
a : Ordinal.{u_1}
ha : (aleph' a).ord = o
⊢ (aleph' (ω + (a - ω))).ord = o
state_after: case h
o : Ordinal.{u_1}
ho : o.card.ord = o
ho' : ω ≤ o
a : Ordinal.{u_1}
ha : (aleph' a).ord = o
⊢ ω ≤ a

tactic: rwa [← aleph0_le_aleph', ← ord_le_ord, ha, ord_aleph0]
state_before: case h
o : Ordinal.{u_1}
ho : o.card.ord = o
ho' : ω ≤ o
a : Ordinal.{u_1}
ha : (aleph' a).ord = o
⊢ ω ≤ a
state_after: no goals
Theorem: Fin.exists_succAbove_eq
File: Mathlib/Data/Fin/Basic.lean

tactic: obtain hxy | hyx := Fin.lt_or_lt_of_ne h
state_before: n m : ℕ
p : Fin (n + 1)
i j : Fin n
x y : Fin (n + 1)
h : x ≠ y
⊢ ∃ z, y.succAbove z = x
state_after: case inl
n m : ℕ
p : Fin (n + 1)
i j : Fin n
x y : Fin (n + 1)
h : x ≠ y
hxy : x < y
⊢ ∃ z, y.succAbove z = x

case inr
n m : ℕ
p : Fin (n + 1)
i j : Fin n
x y : Fin (n + 1)
h : x ≠ y
hyx : y < x
⊢ ∃ z, y.succAbove z = x

tactic: exacts [⟨_, succAbove_castPred_of_lt _ _ hxy⟩, ⟨_, succAbove_pred_of_lt _ _ hyx⟩]
state_before: case inl
n m : ℕ
p : Fin (n + 1)
i j : Fin n
x y : Fin (n + 1)
h : x ≠ y
hxy : x < y
⊢ ∃ z, y.succAbove z = x

case inr
n m : ℕ
p : Fin (n + 1)
i j : Fin n
x y : Fin (n + 1)
h : x ≠ y
hyx : y < x
⊢ ∃ z, y.succAbove z = x
state_after: no goals
Theorem: Nat.factorization_eq_card_pow_dvd
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: simp [← Icc_factorization_eq_pow_dvd n pp]
state_before: a b m n✝ p✝ n p : ℕ
pp : Prime p
⊢ n.factorization p = (Finset.filter (fun i => p ^ i ∣ n) (Ico 1 n)).card
state_after: no goals
Theorem: Matrix.conjTranspose_natCast_smul
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝³ : Semiring R
inst✝² : AddCommMonoid α
inst✝¹ : StarAddMonoid α
inst✝ : Module R α
c : ℕ
M : Matrix m n α
⊢ ∀ (i : n) (j : m), (↑c • M)ᴴ i j = (↑c • Mᴴ) i j
state_after: no goals
Theorem: Cycle.card_toMultiset
File: Mathlib/Data/List/Cycle.lean

tactic: simp
state_before: α : Type u_1
s : Cycle α
⊢ ∀ (a : List α), Multiset.card (toMultiset (Quotient.mk'' a)) = length (Quotient.mk'' a)
state_after: no goals
Theorem: CategoryTheory.IsCofilteredOrEmpty.of_exists_of_isCofiltered_of_fullyFaithful
File: Mathlib/CategoryTheory/Filtered/Final.lean

tactic: suffices IsFilteredOrEmpty Cᵒᵖ from isCofilteredOrEmpty_of_isFilteredOrEmpty_op _
state_before: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝² : IsCofilteredOrEmpty D
inst✝¹ : F.Full
inst✝ : F.Faithful
h : ∀ (d : D), ∃ c, Nonempty (F.obj c ⟶ d)
⊢ IsCofilteredOrEmpty C
state_after: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝² : IsCofilteredOrEmpty D
inst✝¹ : F.Full
inst✝ : F.Faithful
h : ∀ (d : D), ∃ c, Nonempty (F.obj c ⟶ d)
⊢ IsFilteredOrEmpty Cᵒᵖ

tactic: refine IsFilteredOrEmpty.of_exists_of_isFiltered_of_fullyFaithful F.op (fun d => ?_)
state_before: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝² : IsCofilteredOrEmpty D
inst✝¹ : F.Full
inst✝ : F.Faithful
h : ∀ (d : D), ∃ c, Nonempty (F.obj c ⟶ d)
⊢ IsFilteredOrEmpty Cᵒᵖ
state_after: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝² : IsCofilteredOrEmpty D
inst✝¹ : F.Full
inst✝ : F.Faithful
h : ∀ (d : D), ∃ c, Nonempty (F.obj c ⟶ d)
d : Dᵒᵖ
⊢ ∃ c, Nonempty (d ⟶ F.op.obj c)

tactic: obtain ⟨c, ⟨f⟩⟩ := h d.unop
state_before: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝² : IsCofilteredOrEmpty D
inst✝¹ : F.Full
inst✝ : F.Faithful
h : ∀ (d : D), ∃ c, Nonempty (F.obj c ⟶ d)
d : Dᵒᵖ
⊢ ∃ c, Nonempty (d ⟶ F.op.obj c)
state_after: case intro.intro
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝² : IsCofilteredOrEmpty D
inst✝¹ : F.Full
inst✝ : F.Faithful
h : ∀ (d : D), ∃ c, Nonempty (F.obj c ⟶ d)
d : Dᵒᵖ
c : C
f : F.obj c ⟶ d.unop
⊢ ∃ c, Nonempty (d ⟶ F.op.obj c)

tactic: exact ⟨op c, ⟨f.op⟩⟩
state_before: case intro.intro
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝² : IsCofilteredOrEmpty D
inst✝¹ : F.Full
inst✝ : F.Faithful
h : ∀ (d : D), ∃ c, Nonempty (F.obj c ⟶ d)
d : Dᵒᵖ
c : C
f : F.obj c ⟶ d.unop
⊢ ∃ c, Nonempty (d ⟶ F.op.obj c)
state_after: no goals
Theorem: MeasureTheory.measurableEquiv_range_coe_nat_of_infinite_of_countable
File: Mathlib/MeasureTheory/Constructions/Polish.lean

tactic: have : PolishSpace (range ((↑) : ℕ → ℝ)) :=
  Nat.closedEmbedding_coe_real.isClosedMap.isClosed_range.polishSpace
state_before: α : Type u_1
ι : Type u_2
inst✝³ : MeasurableSpace α
inst✝² : StandardBorelSpace α
inst✝¹ : Infinite α
inst✝ : Countable α
⊢ Nonempty (α ≃ᵐ ↑(range Nat.cast))
state_after: α : Type u_1
ι : Type u_2
inst✝³ : MeasurableSpace α
inst✝² : StandardBorelSpace α
inst✝¹ : Infinite α
inst✝ : Countable α
this : PolishSpace ↑(range Nat.cast)
⊢ Nonempty (α ≃ᵐ ↑(range Nat.cast))

tactic: refine ⟨PolishSpace.Equiv.measurableEquiv ?_⟩
state_before: α : Type u_1
ι : Type u_2
inst✝³ : MeasurableSpace α
inst✝² : StandardBorelSpace α
inst✝¹ : Infinite α
inst✝ : Countable α
this : PolishSpace ↑(range Nat.cast)
⊢ Nonempty (α ≃ᵐ ↑(range Nat.cast))
state_after: α : Type u_1
ι : Type u_2
inst✝³ : MeasurableSpace α
inst✝² : StandardBorelSpace α
inst✝¹ : Infinite α
inst✝ : Countable α
this : PolishSpace ↑(range Nat.cast)
⊢ α ≃ ↑(range Nat.cast)

tactic: refine (nonempty_equiv_of_countable.some : α ≃ ℕ).trans ?_
state_before: α : Type u_1
ι : Type u_2
inst✝³ : MeasurableSpace α
inst✝² : StandardBorelSpace α
inst✝¹ : Infinite α
inst✝ : Countable α
this : PolishSpace ↑(range Nat.cast)
⊢ α ≃ ↑(range Nat.cast)
state_after: α : Type u_1
ι : Type u_2
inst✝³ : MeasurableSpace α
inst✝² : StandardBorelSpace α
inst✝¹ : Infinite α
inst✝ : Countable α
this : PolishSpace ↑(range Nat.cast)
⊢ ℕ ≃ ↑(range Nat.cast)

tactic: exact Equiv.ofInjective ((↑) : ℕ → ℝ) Nat.cast_injective
state_before: α : Type u_1
ι : Type u_2
inst✝³ : MeasurableSpace α
inst✝² : StandardBorelSpace α
inst✝¹ : Infinite α
inst✝ : Countable α
this : PolishSpace ↑(range Nat.cast)
⊢ ℕ ≃ ↑(range Nat.cast)
state_after: no goals
Theorem: Finset.prod_eq_prod_diff_singleton_mul
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

tactic: rw [prod_eq_mul_prod_diff_singleton h, mul_comm]
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s : Finset α
i : α
h : i ∈ s
f : α → β
⊢ ∏ x ∈ s, f x = (∏ x ∈ s \ {i}, f x) * f i
state_after: no goals
Theorem: inv_pos_le_iff_one_le_mul'
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [inv_eq_one_div]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
ha : 0 < a
⊢ a⁻¹ ≤ b ↔ 1 ≤ a * b
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
ha : 0 < a
⊢ 1 / a ≤ b ↔ 1 ≤ a * b

tactic: exact div_le_iff' ha
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
ha : 0 < a
⊢ 1 / a ≤ b ↔ 1 ≤ a * b
state_after: no goals
Theorem: MeasureTheory.upcrossingsBefore_zero'
File: Mathlib/Probability/Martingale/Upcrossing.lean

tactic: ext ω
state_before: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
⊢ upcrossingsBefore a b f 0 = 0
state_after: case h
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω✝ : Ω
ℱ : Filtration ℕ m0
ω : Ω
⊢ upcrossingsBefore a b f 0 ω = 0 ω

tactic: exact upcrossingsBefore_zero
state_before: case h
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω✝ : Ω
ℱ : Filtration ℕ m0
ω : Ω
⊢ upcrossingsBefore a b f 0 ω = 0 ω
state_after: no goals
Theorem: EuclideanGeometry.Sphere.mk_center_radius
File: Mathlib/Geometry/Euclidean/Sphere/Basic.lean

tactic: ext <;> rfl
state_before: V : Type u_1
P : Type u_2
inst✝ : MetricSpace P
s : Sphere P
⊢ { center := s.center, radius := s.radius } = s
state_after: no goals
Theorem: CategoryTheory.Equivalence.counitInv_functor_comp
File: Mathlib/CategoryTheory/Equivalence.lean

tactic: erw [Iso.inv_eq_inv (e.functor.mapIso (e.unitIso.app X) ≪≫ e.counitIso.app (e.functor.obj X))
    (Iso.refl _)]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X : C
⊢ e.counitInv.app (e.functor.obj X) ≫ e.functor.map (e.unitInv.app X) = 𝟙 (e.functor.obj X)
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X : C
⊢ (e.functor.mapIso (e.unitIso.app X) ≪≫ e.counitIso.app (e.functor.obj X)).hom =
    (Iso.refl (e.functor.obj ((𝟭 C).obj X))).hom

tactic: exact e.functor_unit_comp X
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X : C
⊢ (e.functor.mapIso (e.unitIso.app X) ≪≫ e.counitIso.app (e.functor.obj X)).hom =
    (Iso.refl (e.functor.obj ((𝟭 C).obj X))).hom
state_after: no goals
Theorem: CategoryTheory.Limits.CokernelCofork.map_condition
File: Mathlib/CategoryTheory/Limits/Preserves/Shapes/Kernels.lean

tactic: rw [← G.map_comp, c.condition, G.map_zero]
state_before: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : HasZeroMorphisms C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasZeroMorphisms D
X Y : C
f : X ⟶ Y
c : CokernelCofork f
G : C ⥤ D
inst✝ : G.PreservesZeroMorphisms
⊢ G.map f ≫ G.map (Cofork.π c) = 0
state_after: no goals