ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: PartialHomeomorph.continuous_univBall
File: Mathlib/Analysis/NormedSpace/HomeomorphBall.lean

Proof steps:
state_before: E : Type u_1
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
P : Type u_2
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor E P
c : P
r : ℝ
⊢ Continuous ↑(univBall c r)
state_after: no goals
tactic: simpa [continuous_iff_continuousOn_univ] using (univBall c r).continuousOn
Theorem: CategoryTheory.Pretriangulated.productTriangle.lift_hom₂
File: Mathlib/CategoryTheory/Triangulated/Basic.lean

Proof steps:
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasShift C ℤ
T₁ T₂ T₃ : Triangle C
J : Type u_1
T : J → Triangle C
inst✝³ : HasProduct fun j => (T j).obj₁
inst✝² : HasProduct fun j => (T j).obj₂
inst✝¹ : HasProduct fun j => (T j).obj₃
inst✝ : HasProduct fun j => (shiftFunctor C 1).obj (T j).obj₁
T' : Triangle C
φ : (j : J) → T' ⟶ T j
⊢ T'.mor₃ ≫ (shiftFunctor C 1).map (Pi.lift fun j => (φ j).hom₁) =
    (Pi.lift fun j => (φ j).hom₃) ≫ (productTriangle T).mor₃
state_after: C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasShift C ℤ
T₁ T₂ T₃ : Triangle C
J : Type u_1
T : J → Triangle C
inst✝³ : HasProduct fun j => (T j).obj₁
inst✝² : HasProduct fun j => (T j).obj₂
inst✝¹ : HasProduct fun j => (T j).obj₃
inst✝ : HasProduct fun j => (shiftFunctor C 1).obj (T j).obj₁
T' : Triangle C
φ : (j : J) → T' ⟶ T j
⊢ T'.mor₃ ≫ (shiftFunctor C 1).map (Pi.lift fun j => (φ j).hom₁) =
    (Pi.lift fun j => (φ j).hom₃) ≫
      (Pi.map fun j => (T j).mor₃) ≫ inv (piComparison (shiftFunctor C 1) fun j => (T j).obj₁)
tactic: dsimp
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasShift C ℤ
T₁ T₂ T₃ : Triangle C
J : Type u_1
T : J → Triangle C
inst✝³ : HasProduct fun j => (T j).obj₁
inst✝² : HasProduct fun j => (T j).obj₂
inst✝¹ : HasProduct fun j => (T j).obj₃
inst✝ : HasProduct fun j => (shiftFunctor C 1).obj (T j).obj₁
T' : Triangle C
φ : (j : J) → T' ⟶ T j
⊢ T'.mor₃ ≫ (shiftFunctor C 1).map (Pi.lift fun j => (φ j).hom₁) =
    (Pi.lift fun j => (φ j).hom₃) ≫
      (Pi.map fun j => (T j).mor₃) ≫ inv (piComparison (shiftFunctor C 1) fun j => (T j).obj₁)
state_after: C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasShift C ℤ
T₁ T₂ T₃ : Triangle C
J : Type u_1
T : J → Triangle C
inst✝³ : HasProduct fun j => (T j).obj₁
inst✝² : HasProduct fun j => (T j).obj₂
inst✝¹ : HasProduct fun j => (T j).obj₃
inst✝ : HasProduct fun j => (shiftFunctor C 1).obj (T j).obj₁
T' : Triangle C
φ : (j : J) → T' ⟶ T j
⊢ (T'.mor₃ ≫
      (shiftFunctor C 1).map (Pi.lift fun j => (φ j).hom₁) ≫ piComparison (shiftFunctor C 1) fun j => (T j).obj₁) =
    (Pi.lift fun j => (φ j).hom₃) ≫ Pi.map fun j => (T j).mor₃
tactic: rw [← cancel_mono (piComparison _ _), assoc, assoc, assoc, IsIso.inv_hom_id, comp_id]
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasShift C ℤ
T₁ T₂ T₃ : Triangle C
J : Type u_1
T : J → Triangle C
inst✝³ : HasProduct fun j => (T j).obj₁
inst✝² : HasProduct fun j => (T j).obj₂
inst✝¹ : HasProduct fun j => (T j).obj₃
inst✝ : HasProduct fun j => (shiftFunctor C 1).obj (T j).obj₁
T' : Triangle C
φ : (j : J) → T' ⟶ T j
⊢ (T'.mor₃ ≫
      (shiftFunctor C 1).map (Pi.lift fun j => (φ j).hom₁) ≫ piComparison (shiftFunctor C 1) fun j => (T j).obj₁) =
    (Pi.lift fun j => (φ j).hom₃) ≫ Pi.map fun j => (T j).mor₃
state_after: no goals
tactic: aesop_cat
Theorem: CategoryTheory.PreGaloisCategory.autMap_id
File: Mathlib/CategoryTheory/Galois/GaloisObjects.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : GaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
A : C
inst✝ : IsGalois A
σ : Aut A
⊢ 𝟙 A ≫ (id σ).hom = σ.hom ≫ 𝟙 A
state_after: no goals
tactic: simp
Theorem: Real.sin_eq_zero_iff_of_lt_of_lt
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

Proof steps:
state_before: x : ℝ
hx₁ : -π < x
hx₂ : x < π
h : sin x = 0
⊢ x = 0
state_after: x : ℝ
hx₁ : -π < x
hx₂ : x < π
h : x ≠ 0
⊢ sin x ≠ 0
tactic: contrapose! h
state_before: x : ℝ
hx₁ : -π < x
hx₂ : x < π
h : x ≠ 0
⊢ sin x ≠ 0
state_after: no goals
tactic: cases h.lt_or_lt with
    | inl h0 => exact (sin_neg_of_neg_of_neg_pi_lt h0 hx₁).ne
    | inr h0 => exact (sin_pos_of_pos_of_lt_pi h0 hx₂).ne'
state_before: x : ℝ
hx₁ : -π < x
hx₂ : x < π
h : x = 0
⊢ sin x = 0
state_after: no goals
tactic: simp [h]
Theorem: String.utf8Len_eq_zero
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

Proof steps:
state_before: l : List Char
⊢ utf8Len l = 0 ↔ l = []
state_after: no goals
tactic: cases l <;> simp [Nat.ne_of_gt add_csize_pos]
Theorem: CategoryTheory.ShortComplex.rightHomologyMapIso'_inv
File: Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.114018, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
e : S₁ ≅ S₂
h₁ : S₁.RightHomologyData
h₂ : S₂.RightHomologyData
⊢ rightHomologyMap' e.hom h₁ h₂ ≫ rightHomologyMap' e.inv h₂ h₁ = 𝟙 h₁.H
state_after: no goals
tactic: rw [← rightHomologyMap'_comp, e.hom_inv_id, rightHomologyMap'_id]
state_before: C : Type u_1
inst✝¹ : Category.{?u.114018, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
e : S₁ ≅ S₂
h₁ : S₁.RightHomologyData
h₂ : S₂.RightHomologyData
⊢ rightHomologyMap' e.inv h₂ h₁ ≫ rightHomologyMap' e.hom h₁ h₂ = 𝟙 h₂.H
state_after: no goals
tactic: rw [← rightHomologyMap'_comp, e.inv_hom_id, rightHomologyMap'_id]
Theorem: right_eq_midpoint_iff
File: Mathlib/LinearAlgebra/AffineSpace/Midpoint.lean

Proof steps:
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁷ : Ring R
inst✝⁶ : Invertible 2
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x✝ y✝ z x y : P
⊢ y = midpoint R x y ↔ x = y
state_after: no goals
tactic: rw [eq_comm, midpoint_eq_right_iff]
Theorem: Fin.castSucc_eq_zero_iff'
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
inst✝ : NeZero n
a : Fin n
⊢ ↑a = ↑0 ↔ ↑a.castSucc = ↑0
state_after: no goals
tactic: simp
Theorem: StrictConvexOn.map_sum_eq_iff
File: Mathlib/Analysis/Convex/Jensen.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
ι : Type u_5
inst✝⁵ : LinearOrderedField 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : OrderedAddCommGroup β
inst✝² : Module 𝕜 E
inst✝¹ : Module 𝕜 β
inst✝ : OrderedSMul 𝕜 β
s : Set E
f : E → β
t : Finset ι
w✝ : ι → 𝕜
p✝ : ι → E
v : 𝕜
q : E
w : ι → 𝕜
p : ι → E
hf : StrictConvexOn 𝕜 s f
h₀ : ∀ i ∈ t, 0 < w i
h₁ : ∑ i ∈ t, w i = 1
hmem : ∀ i ∈ t, p i ∈ s
⊢ f (∑ i ∈ t, w i • p i) = ∑ i ∈ t, w i • f (p i) ↔ ∀ j ∈ t, p j = ∑ i ∈ t, w i • p i
state_after: case mp
𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
ι : Type u_5
inst✝⁵ : LinearOrderedField 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : OrderedAddCommGroup β
inst✝² : Module 𝕜 E
inst✝¹ : Module 𝕜 β
inst✝ : OrderedSMul 𝕜 β
s : Set E
f : E → β
t : Finset ι
w✝ : ι → 𝕜
p✝ : ι → E
v : 𝕜
q : E
w : ι → 𝕜
p : ι → E
hf : StrictConvexOn 𝕜 s f
h₀ : ∀ i ∈ t, 0 < w i
h₁ : ∑ i ∈ t, w i = 1
hmem : ∀ i ∈ t, p i ∈ s
⊢ f (∑ i ∈ t, w i • p i) = ∑ i ∈ t, w i • f (p i) → ∀ j ∈ t, p j = ∑ i ∈ t, w i • p i

case mpr
𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
ι : Type u_5
inst✝⁵ : LinearOrderedField 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : OrderedAddCommGroup β
inst✝² : Module 𝕜 E
inst✝¹ : Module 𝕜 β
inst✝ : OrderedSMul 𝕜 β
s : Set E
f : E → β
t : Finset ι
w✝ : ι → 𝕜
p✝ : ι → E
v : 𝕜
q : E
w : ι → 𝕜
p : ι → E
hf : StrictConvexOn 𝕜 s f
h₀ : ∀ i ∈ t, 0 < w i
h₁ : ∑ i ∈ t, w i = 1
hmem : ∀ i ∈ t, p i ∈ s
⊢ (∀ j ∈ t, p j = ∑ i ∈ t, w i • p i) → f (∑ i ∈ t, w i • p i) = ∑ i ∈ t, w i • f (p i)
tactic: constructor
Theorem: HasDerivAt.div_const
File: Mathlib/Analysis/Calculus/Deriv/Mul.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
E : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
G : Type u_1
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_2
inst✝¹ : NontriviallyNormedField 𝕜'
inst✝ : NormedAlgebra 𝕜 𝕜'
c d✝ : 𝕜 → 𝕜'
c' d' : 𝕜'
hc : HasDerivAt c c' x
d : 𝕜'
⊢ HasDerivAt (fun x => c x / d) (c' / d) x
state_after: no goals
tactic: simpa only [div_eq_mul_inv] using hc.mul_const d⁻¹
Theorem: Submodule.sup_toAddSubgroup
File: Mathlib/LinearAlgebra/Span.lean

Proof steps:
state_before: R✝ : Type u_1
R₂ : Type u_2
K : Type u_3
M✝ : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝¹⁰ : Semiring R✝
inst✝⁹ : AddCommMonoid M✝
inst✝⁸ : Module R✝ M✝
x : M✝
p✝ p'✝ : Submodule R✝ M✝
inst✝⁷ : Semiring R₂
σ₁₂ : R✝ →+* R₂
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : Module R₂ M₂
F : Type u_8
inst✝⁴ : FunLike F M✝ M₂
inst✝³ : SemilinearMapClass F σ₁₂ M✝ M₂
s t : Set M✝
R : Type u_9
M : Type u_10
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p p' : Submodule R M
⊢ (p ⊔ p').toAddSubgroup = p.toAddSubgroup ⊔ p'.toAddSubgroup
state_after: case h
R✝ : Type u_1
R₂ : Type u_2
K : Type u_3
M✝ : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝¹⁰ : Semiring R✝
inst✝⁹ : AddCommMonoid M✝
inst✝⁸ : Module R✝ M✝
x✝ : M✝
p✝ p'✝ : Submodule R✝ M✝
inst✝⁷ : Semiring R₂
σ₁₂ : R✝ →+* R₂
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : Module R₂ M₂
F : Type u_8
inst✝⁴ : FunLike F M✝ M₂
inst✝³ : SemilinearMapClass F σ₁₂ M✝ M₂
s t : Set M✝
R : Type u_9
M : Type u_10
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p p' : Submodule R M
x : M
⊢ x ∈ (p ⊔ p').toAddSubgroup ↔ x ∈ p.toAddSubgroup ⊔ p'.toAddSubgroup
tactic: ext x
state_before: case h
R✝ : Type u_1
R₂ : Type u_2
K : Type u_3
M✝ : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝¹⁰ : Semiring R✝
inst✝⁹ : AddCommMonoid M✝
inst✝⁸ : Module R✝ M✝
x✝ : M✝
p✝ p'✝ : Submodule R✝ M✝
inst✝⁷ : Semiring R₂
σ₁₂ : R✝ →+* R₂
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : Module R₂ M₂
F : Type u_8
inst✝⁴ : FunLike F M✝ M₂
inst✝³ : SemilinearMapClass F σ₁₂ M✝ M₂
s t : Set M✝
R : Type u_9
M : Type u_10
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p p' : Submodule R M
x : M
⊢ x ∈ (p ⊔ p').toAddSubgroup ↔ x ∈ p.toAddSubgroup ⊔ p'.toAddSubgroup
state_after: case h
R✝ : Type u_1
R₂ : Type u_2
K : Type u_3
M✝ : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝¹⁰ : Semiring R✝
inst✝⁹ : AddCommMonoid M✝
inst✝⁸ : Module R✝ M✝
x✝ : M✝
p✝ p'✝ : Submodule R✝ M✝
inst✝⁷ : Semiring R₂
σ₁₂ : R✝ →+* R₂
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : Module R₂ M₂
F : Type u_8
inst✝⁴ : FunLike F M✝ M₂
inst✝³ : SemilinearMapClass F σ₁₂ M✝ M₂
s t : Set M✝
R : Type u_9
M : Type u_10
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p p' : Submodule R M
x : M
⊢ (∃ y ∈ p, ∃ z ∈ p', y + z = x) ↔ ∃ y ∈ p.toAddSubgroup, ∃ z ∈ p'.toAddSubgroup, y + z = x
tactic: rw [mem_toAddSubgroup, mem_sup, AddSubgroup.mem_sup]
state_before: case h
R✝ : Type u_1
R₂ : Type u_2
K : Type u_3
M✝ : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝¹⁰ : Semiring R✝
inst✝⁹ : AddCommMonoid M✝
inst✝⁸ : Module R✝ M✝
x✝ : M✝
p✝ p'✝ : Submodule R✝ M✝
inst✝⁷ : Semiring R₂
σ₁₂ : R✝ →+* R₂
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : Module R₂ M₂
F : Type u_8
inst✝⁴ : FunLike F M✝ M₂
inst✝³ : SemilinearMapClass F σ₁₂ M✝ M₂
s t : Set M✝
R : Type u_9
M : Type u_10
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p p' : Submodule R M
x : M
⊢ (∃ y ∈ p, ∃ z ∈ p', y + z = x) ↔ ∃ y ∈ p.toAddSubgroup, ∃ z ∈ p'.toAddSubgroup, y + z = x
state_after: no goals
tactic: rfl
Theorem: SimpleGraph.Subgraph.inclusion.injective
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

Proof steps:
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
x y : G.Subgraph
h : x ≤ y
⊢ Function.Injective ⇑(inclusion h)
state_after: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
x y : G.Subgraph
h✝ : x ≤ y
v w : ↑x.verts
h : (inclusion h✝) v = (inclusion h✝) w
⊢ v = w
tactic: intro v w h
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
x y : G.Subgraph
h✝ : x ≤ y
v w : ↑x.verts
h : (inclusion h✝) v = (inclusion h✝) w
⊢ v = w
state_after: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
x y : G.Subgraph
h✝ : x ≤ y
v w : ↑x.verts
h :
  ↑(RelHom.instFunLike.1 { toFun := fun v => ⟨↑v, ⋯⟩, map_rel' := ⋯ } v) =
    ↑(RelHom.instFunLike.1 { toFun := fun v => ⟨↑v, ⋯⟩, map_rel' := ⋯ } w)
⊢ v = w
tactic: rw [inclusion, DFunLike.coe, Subtype.mk_eq_mk] at h
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
x y : G.Subgraph
h✝ : x ≤ y
v w : ↑x.verts
h :
  ↑(RelHom.instFunLike.1 { toFun := fun v => ⟨↑v, ⋯⟩, map_rel' := ⋯ } v) =
    ↑(RelHom.instFunLike.1 { toFun := fun v => ⟨↑v, ⋯⟩, map_rel' := ⋯ } w)
⊢ v = w
state_after: no goals
tactic: exact Subtype.ext h
Theorem: Order.pred_eq_iSup
File: Mathlib/Order/SuccPred/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : CompleteLattice α
inst✝ : PredOrder α
a : α
⊢ pred a = ⨆ b, ⨆ (_ : b < a), b
state_after: α : Type u_1
β : Type u_2
inst✝¹ : CompleteLattice α
inst✝ : PredOrder α
a : α
⊢ pred a ≤ ⨆ b, ⨆ (_ : b < a), b
tactic: refine le_antisymm ?_ (iSup_le fun b => iSup_le le_pred_of_lt)
state_before: α : Type u_1
β : Type u_2
inst✝¹ : CompleteLattice α
inst✝ : PredOrder α
a : α
⊢ pred a ≤ ⨆ b, ⨆ (_ : b < a), b
state_after: case inl
α : Type u_1
β : Type u_2
inst✝¹ : CompleteLattice α
inst✝ : PredOrder α
⊢ pred ⊥ ≤ ⨆ b, ⨆ (_ : b < ⊥), b

case inr
α : Type u_1
β : Type u_2
inst✝¹ : CompleteLattice α
inst✝ : PredOrder α
a : α
ha : a ≠ ⊥
⊢ pred a ≤ ⨆ b, ⨆ (_ : b < a), b
tactic: obtain rfl | ha := eq_or_ne a ⊥
Theorem: Matrix.conjTranspose_col
File: Mathlib/Data/Matrix/RowCol.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
inst✝ : Star α
v : m → α
⊢ (col ι v)ᴴ = row ι (star v)
state_after: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
inst✝ : Star α
v : m → α
i✝ : ι
j✝ : m
⊢ (col ι v)ᴴ i✝ j✝ = row ι (star v) i✝ j✝
tactic: ext
state_before: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
inst✝ : Star α
v : m → α
i✝ : ι
j✝ : m
⊢ (col ι v)ᴴ i✝ j✝ = row ι (star v) i✝ j✝
state_after: no goals
tactic: rfl
Theorem: List.fillNones_eq_fillNonesTR.go
File: .lake/packages/batteries/Batteries/Data/List/Basic.lean

Proof steps:
state_before: ⊢ @fillNones = @fillNonesTR
state_after: case h.h.h
α : Type u_1
as : List (Option α)
as' : List α
⊢ as.fillNones as' = as.fillNonesTR as'
tactic: funext α as as'
state_before: case h.h.h
α : Type u_1
as : List (Option α)
as' : List α
⊢ as.fillNones as' = as.fillNonesTR as'
state_after: case h.h.h
α : Type u_1
as : List (Option α)
as' : List α
⊢ as.fillNones as' = fillNonesTR.go as as' #[]
tactic: simp [fillNonesTR]
state_before: α : Type u_1
as : List (Option α)
as' : List α
acc : Array α
x✝ : List α
⊢ fillNonesTR.go [] x✝ acc = acc.data ++ [].fillNones x✝
state_after: no goals
tactic: simp [fillNonesTR.go]
state_before: α : Type u_1
as✝ : List (Option α)
as'✝ : List α
acc : Array α
a : α
as : List (Option α)
as' : List α
⊢ fillNonesTR.go (some a :: as) as' acc = acc.data ++ (some a :: as).fillNones as'
state_after: no goals
tactic: simp [fillNonesTR.go, go _ as as']
state_before: α : Type u_1
as✝ : List (Option α)
as' : List α
acc : Array α
as : List (Option α)
⊢ fillNonesTR.go (none :: as) [] acc = acc.data ++ (none :: as).fillNones []
state_after: no goals
tactic: simp [fillNonesTR.go, reduceOption, filterMap_eq_filterMapTR.go]
state_before: α : Type u_1
as✝ : List (Option α)
as'✝ : List α
acc : Array α
as : List (Option α)
a : α
as' : List α
⊢ fillNonesTR.go (none :: as) (a :: as') acc = acc.data ++ (none :: as).fillNones (a :: as')
state_after: no goals
tactic: simp [fillNonesTR.go, go _ as as']
state_before: case h.h.h
α : Type u_1
as : List (Option α)
as' : List α
⊢ as.fillNones as' = fillNonesTR.go as as' #[]
state_after: no goals
tactic: simp [fillNonesTR, go]
Theorem: List.zipWith_comm_of_comm
File: Mathlib/Data/List/Zip.lean

Proof steps:
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
f : α → α → β
comm : ∀ (x y : α), f x y = f y x
l l' : List α
⊢ zipWith f l l' = zipWith f l' l
state_after: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
f : α → α → β
comm : ∀ (x y : α), f x y = f y x
l l' : List α
⊢ zipWith (fun b a => f a b) l' l = zipWith f l' l
tactic: rw [zipWith_comm]
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
f : α → α → β
comm : ∀ (x y : α), f x y = f y x
l l' : List α
⊢ zipWith (fun b a => f a b) l' l = zipWith f l' l
state_after: no goals
tactic: simp only [comm]
Theorem: CategoryTheory.IsFiltered.bowtie
File: Mathlib/CategoryTheory/Filtered/Basic.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : IsFilteredOrEmpty C
j₁ j₂ k₁ k₂ : C
f₁ : j₁ ⟶ k₁
g₁ : j₁ ⟶ k₂
f₂ : j₂ ⟶ k₁
g₂ : j₂ ⟶ k₂
⊢ ∃ s α β, f₁ ≫ α = g₁ ≫ β ∧ f₂ ≫ α = g₂ ≫ β
state_after: case intro.intro.intro
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : IsFilteredOrEmpty C
j₁ j₂ k₁ k₂ : C
f₁ : j₁ ⟶ k₁
g₁ : j₁ ⟶ k₂
f₂ : j₂ ⟶ k₁
g₂ : j₂ ⟶ k₂
t : C
k₁t : k₁ ⟶ t
k₂t : k₂ ⟶ t
ht : f₁ ≫ k₁t = g₁ ≫ k₂t
⊢ ∃ s α β, f₁ ≫ α = g₁ ≫ β ∧ f₂ ≫ α = g₂ ≫ β
tactic: obtain ⟨t, k₁t, k₂t, ht⟩ := span f₁ g₁
state_before: case intro.intro.intro
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : IsFilteredOrEmpty C
j₁ j₂ k₁ k₂ : C
f₁ : j₁ ⟶ k₁
g₁ : j₁ ⟶ k₂
f₂ : j₂ ⟶ k₁
g₂ : j₂ ⟶ k₂
t : C
k₁t : k₁ ⟶ t
k₂t : k₂ ⟶ t
ht : f₁ ≫ k₁t = g₁ ≫ k₂t
⊢ ∃ s α β, f₁ ≫ α = g₁ ≫ β ∧ f₂ ≫ α = g₂ ≫ β
state_after: case intro.intro.intro.intro.intro
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : IsFilteredOrEmpty C
j₁ j₂ k₁ k₂ : C
f₁ : j₁ ⟶ k₁
g₁ : j₁ ⟶ k₂
f₂ : j₂ ⟶ k₁
g₂ : j₂ ⟶ k₂
t : C
k₁t : k₁ ⟶ t
k₂t : k₂ ⟶ t
ht : f₁ ≫ k₁t = g₁ ≫ k₂t
s : C
ts : t ⟶ s
hs : (f₂ ≫ k₁t) ≫ ts = (g₂ ≫ k₂t) ≫ ts
⊢ ∃ s α β, f₁ ≫ α = g₁ ≫ β ∧ f₂ ≫ α = g₂ ≫ β
tactic: obtain ⟨s, ts, hs⟩ := IsFilteredOrEmpty.cocone_maps (f₂ ≫ k₁t) (g₂ ≫ k₂t)
state_before: case intro.intro.intro.intro.intro
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : IsFilteredOrEmpty C
j₁ j₂ k₁ k₂ : C
f₁ : j₁ ⟶ k₁
g₁ : j₁ ⟶ k₂
f₂ : j₂ ⟶ k₁
g₂ : j₂ ⟶ k₂
t : C
k₁t : k₁ ⟶ t
k₂t : k₂ ⟶ t
ht : f₁ ≫ k₁t = g₁ ≫ k₂t
s : C
ts : t ⟶ s
hs : (f₂ ≫ k₁t) ≫ ts = (g₂ ≫ k₂t) ≫ ts
⊢ ∃ s α β, f₁ ≫ α = g₁ ≫ β ∧ f₂ ≫ α = g₂ ≫ β
state_after: case intro.intro.intro.intro.intro
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : IsFilteredOrEmpty C
j₁ j₂ k₁ k₂ : C
f₁ : j₁ ⟶ k₁
g₁ : j₁ ⟶ k₂
f₂ : j₂ ⟶ k₁
g₂ : j₂ ⟶ k₂
t : C
k₁t : k₁ ⟶ t
k₂t : k₂ ⟶ t
ht : f₁ ≫ k₁t = g₁ ≫ k₂t
s : C
ts : t ⟶ s
hs : f₂ ≫ k₁t ≫ ts = g₂ ≫ k₂t ≫ ts
⊢ ∃ s α β, f₁ ≫ α = g₁ ≫ β ∧ f₂ ≫ α = g₂ ≫ β
tactic: simp_rw [Category.assoc] at hs
state_before: case intro.intro.intro.intro.intro
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : IsFilteredOrEmpty C
j₁ j₂ k₁ k₂ : C
f₁ : j₁ ⟶ k₁
g₁ : j₁ ⟶ k₂
f₂ : j₂ ⟶ k₁
g₂ : j₂ ⟶ k₂
t : C
k₁t : k₁ ⟶ t
k₂t : k₂ ⟶ t
ht : f₁ ≫ k₁t = g₁ ≫ k₂t
s : C
ts : t ⟶ s
hs : f₂ ≫ k₁t ≫ ts = g₂ ≫ k₂t ≫ ts
⊢ ∃ s α β, f₁ ≫ α = g₁ ≫ β ∧ f₂ ≫ α = g₂ ≫ β
state_after: no goals
tactic: exact ⟨s, k₁t ≫ ts, k₂t ≫ ts, by simp only [← Category.assoc, ht], hs⟩
Theorem: ContinuousMultilinearMap.opNNNorm_prod
File: Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean

Proof steps:
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
G : Type wG
G' : Type wG'
inst✝¹⁵ : Fintype ι
inst✝¹⁴ : Fintype ι'
inst✝¹³ : NontriviallyNormedField 𝕜
inst✝¹² : (i : ι) → SeminormedAddCommGroup (E i)
inst✝¹¹ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝¹⁰ : (i : ι) → SeminormedAddCommGroup (E₁ i)
inst✝⁹ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁸ : (i : ι') → SeminormedAddCommGroup (E' i)
inst✝⁷ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁶ : SeminormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
inst✝⁴ : SeminormedAddCommGroup G'
inst✝³ : NormedSpace 𝕜 G'
c : 𝕜
f✝ g✝ : ContinuousMultilinearMap 𝕜 E G
m : (i : ι) → E i
𝕜' : Type u_1
inst✝² : NormedField 𝕜'
inst✝¹ : NormedSpace 𝕜' G
inst✝ : SMulCommClass 𝕜 𝕜' G
f : ContinuousMultilinearMap 𝕜 E G
g : ContinuousMultilinearMap 𝕜 E G'
x✝ : ℝ≥0
⊢ ‖f.prod g‖₊ ≤ x✝ ↔ max ‖f‖₊ ‖g‖₊ ≤ x✝
state_after: no goals
tactic: simp only [opNNNorm_le_iff, prod_apply, Prod.nnnorm_def', max_le_iff, forall_and]
Theorem: exists_mem_nhdsSet_isCompact_mapsTo
File: Mathlib/Topology/Compactness/LocallyCompact.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
ι : Type u_3
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t : Set X
inst✝ : LocallyCompactPair X Y
f : X → Y
K : Set X
U : Set Y
hf : Continuous f
hK : IsCompact K
hU : IsOpen U
hKU : MapsTo f K U
⊢ ∃ L ∈ 𝓝ˢ K, IsCompact L ∧ MapsTo f L U
state_after: X : Type u_1
Y : Type u_2
ι : Type u_3
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t : Set X
inst✝ : LocallyCompactPair X Y
f : X → Y
K : Set X
U : Set Y
hf : Continuous f
hK : IsCompact K
hU : IsOpen U
hKU : MapsTo f K U
V : X → Set X
hxV : ∀ x ∈ K, V x ∈ 𝓝 x
hVc : ∀ x ∈ K, IsCompact (V x)
hVU : ∀ x ∈ K, MapsTo f (V x) U
⊢ ∃ L ∈ 𝓝ˢ K, IsCompact L ∧ MapsTo f L U
tactic: choose! V hxV hVc hVU using fun x (hx : x ∈ K) ↦
    exists_mem_nhds_isCompact_mapsTo hf (hU.mem_nhds (hKU hx))
state_before: X : Type u_1
Y : Type u_2
ι : Type u_3
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t : Set X
inst✝ : LocallyCompactPair X Y
f : X → Y
K : Set X
U : Set Y
hf : Continuous f
hK : IsCompact K
hU : IsOpen U
hKU : MapsTo f K U
V : X → Set X
hxV : ∀ x ∈ K, V x ∈ 𝓝 x
hVc : ∀ x ∈ K, IsCompact (V x)
hVU : ∀ x ∈ K, MapsTo f (V x) U
⊢ ∃ L ∈ 𝓝ˢ K, IsCompact L ∧ MapsTo f L U
state_after: case intro.intro
X : Type u_1
Y : Type u_2
ι : Type u_3
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s✝ t : Set X
inst✝ : LocallyCompactPair X Y
f : X → Y
K : Set X
U : Set Y
hf : Continuous f
hK : IsCompact K
hU : IsOpen U
hKU : MapsTo f K U
V : X → Set X
hxV : ∀ x ∈ K, V x ∈ 𝓝 x
hVc : ∀ x ∈ K, IsCompact (V x)
hVU : ∀ x ∈ K, MapsTo f (V x) U
s : Finset X
hsK : ∀ x ∈ s, x ∈ K
hKs : ⋃ x ∈ s, V x ∈ 𝓝ˢ K
⊢ ∃ L ∈ 𝓝ˢ K, IsCompact L ∧ MapsTo f L U
tactic: rcases hK.elim_nhds_subcover_nhdsSet hxV with ⟨s, hsK, hKs⟩
state_before: case intro.intro
X : Type u_1
Y : Type u_2
ι : Type u_3
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s✝ t : Set X
inst✝ : LocallyCompactPair X Y
f : X → Y
K : Set X
U : Set Y
hf : Continuous f
hK : IsCompact K
hU : IsOpen U
hKU : MapsTo f K U
V : X → Set X
hxV : ∀ x ∈ K, V x ∈ 𝓝 x
hVc : ∀ x ∈ K, IsCompact (V x)
hVU : ∀ x ∈ K, MapsTo f (V x) U
s : Finset X
hsK : ∀ x ∈ s, x ∈ K
hKs : ⋃ x ∈ s, V x ∈ 𝓝ˢ K
⊢ ∃ L ∈ 𝓝ˢ K, IsCompact L ∧ MapsTo f L U
state_after: no goals
tactic: exact ⟨_, hKs, s.isCompact_biUnion fun x hx ↦ hVc x (hsK x hx), mapsTo_iUnion₂.2 fun x hx ↦
    hVU x (hsK x hx)⟩
Theorem: Nat.testBit_two_pow
File: Mathlib/Data/Nat/Bitwise.lean

Proof steps:
state_before: n m : ℕ
⊢ ((2 ^ n).testBit m = true) = (n = m)
state_after: case pos
n m : ℕ
h : n = m
⊢ ((2 ^ n).testBit m = true) = (n = m)

case neg
n m : ℕ
h : ¬n = m
⊢ ((2 ^ n).testBit m = true) = (n = m)
tactic: by_cases h : n = m
Theorem: List.IsPrefix.getElem
File: Mathlib/Data/List/Infix.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a b : α
m n✝ : ℕ
x y : List α
h : x <+: y
n : ℕ
hn : n < x.length
⊢ x[n] = y[n]
state_after: case intro
α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a b : α
m n✝ : ℕ
x : List α
n : ℕ
hn : n < x.length
w✝ : List α
⊢ x[n] = (x ++ w✝)[n]
tactic: obtain ⟨_, rfl⟩ := h
state_before: case intro
α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a b : α
m n✝ : ℕ
x : List α
n : ℕ
hn : n < x.length
w✝ : List α
⊢ x[n] = (x ++ w✝)[n]
state_after: no goals
tactic: exact (List.getElem_append n hn).symm
Theorem: GenContFract.zero_le_of_den
File: Mathlib/Algebra/ContinuedFractions/Computation/Approximations.lean

Proof steps:
state_before: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
⊢ 0 ≤ (of v).dens n
state_after: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
⊢ 0 ≤ ((of v).contsAux (n + 1)).b
tactic: rw [den_eq_conts_b, nth_cont_eq_succ_nth_contAux]
state_before: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
⊢ 0 ≤ ((of v).contsAux (n + 1)).b
state_after: no goals
tactic: exact zero_le_of_contsAux_b