ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Set.MapsTo.piecewise_ite
File: Mathlib/Data/Set/Function.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
δ : α → Sort u_6
s✝ : Set α
f g : (i : α) → δ i
inst✝¹ : (j : α) → Decidable (j ∈ s✝)
s s₁ s₂ : Set α
t t₁ t₂ : Set β
f₁ f₂ : α → β
inst✝ : (i : α) → Decidable (i ∈ s)
h₁ : MapsTo f₁ (s₁ ∩ s) (t₁ ∩ t)
h₂ : MapsTo f₂ (s₂ ∩ sᶜ) (t₂ ∩ tᶜ)
⊢ MapsTo (s.piecewise f₁ f₂) (s.ite s₁ s₂) (t.ite t₁ t₂)
state_after: case refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
δ : α → Sort u_6
s✝ : Set α
f g : (i : α) → δ i
inst✝¹ : (j : α) → Decidable (j ∈ s✝)
s s₁ s₂ : Set α
t t₁ t₂ : Set β
f₁ f₂ : α → β
inst✝ : (i : α) → Decidable (i ∈ s)
h₁ : MapsTo f₁ (s₁ ∩ s) (t₁ ∩ t)
h₂ : MapsTo f₂ (s₂ ∩ sᶜ) (t₂ ∩ tᶜ)
⊢ EqOn f₁ (s.piecewise f₁ f₂) (s₁ ∩ s)

case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
δ : α → Sort u_6
s✝ : Set α
f g : (i : α) → δ i
inst✝¹ : (j : α) → Decidable (j ∈ s✝)
s s₁ s₂ : Set α
t t₁ t₂ : Set β
f₁ f₂ : α → β
inst✝ : (i : α) → Decidable (i ∈ s)
h₁ : MapsTo f₁ (s₁ ∩ s) (t₁ ∩ t)
h₂ : MapsTo f₂ (s₂ ∩ sᶜ) (t₂ ∩ tᶜ)
⊢ EqOn f₂ (s.piecewise f₁ f₂) (s₂ ∩ sᶜ)
tactic: refine (h₁.congr ?_).union_union (h₂.congr ?_)
state_before: case refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
δ : α → Sort u_6
s✝ : Set α
f g : (i : α) → δ i
inst✝¹ : (j : α) → Decidable (j ∈ s✝)
s s₁ s₂ : Set α
t t₁ t₂ : Set β
f₁ f₂ : α → β
inst✝ : (i : α) → Decidable (i ∈ s)
h₁ : MapsTo f₁ (s₁ ∩ s) (t₁ ∩ t)
h₂ : MapsTo f₂ (s₂ ∩ sᶜ) (t₂ ∩ tᶜ)
⊢ EqOn f₁ (s.piecewise f₁ f₂) (s₁ ∩ s)

case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
δ : α → Sort u_6
s✝ : Set α
f g : (i : α) → δ i
inst✝¹ : (j : α) → Decidable (j ∈ s✝)
s s₁ s₂ : Set α
t t₁ t₂ : Set β
f₁ f₂ : α → β
inst✝ : (i : α) → Decidable (i ∈ s)
h₁ : MapsTo f₁ (s₁ ∩ s) (t₁ ∩ t)
h₂ : MapsTo f₂ (s₂ ∩ sᶜ) (t₂ ∩ tᶜ)
⊢ EqOn f₂ (s.piecewise f₁ f₂) (s₂ ∩ sᶜ)
state_after: no goals
tactic: exacts [(piecewise_eqOn s f₁ f₂).symm.mono inter_subset_right,
    (piecewise_eqOn_compl s f₁ f₂).symm.mono inter_subset_right]
Theorem: BoxIntegral.Prepartition.split_of_not_mem_Ioo
File: Mathlib/Analysis/BoxIntegral/Partition/Split.lean

Proof steps:
state_before: ι : Type u_1
M : Type u_2
n : ℕ
I J : Box ι
i : ι
x : ℝ
h : x ∉ Ioo (I.lower i) (I.upper i)
⊢ split I i x = ⊤
state_after: ι : Type u_1
M : Type u_2
n : ℕ
I J✝ : Box ι
i : ι
x : ℝ
h : x ∉ Ioo (I.lower i) (I.upper i)
J : Box ι
hJ : J ∈ ⊤.boxes
⊢ J ∈ (split I i x).boxes
tactic: refine ((isPartitionTop I).eq_of_boxes_subset fun J hJ => ?_).symm
state_before: ι : Type u_1
M : Type u_2
n : ℕ
I J✝ : Box ι
i : ι
x : ℝ
h : x ∉ Ioo (I.lower i) (I.upper i)
J : Box ι
hJ : J ∈ ⊤.boxes
⊢ J ∈ (split I i x).boxes
state_after: ι : Type u_1
M : Type u_2
n : ℕ
J✝ : Box ι
i : ι
x : ℝ
J : Box ι
h : x ∉ Ioo (J.lower i) (J.upper i)
hJ : J ∈ ⊤.boxes
⊢ J ∈ (split J i x).boxes
tactic: rcases mem_top.1 hJ with rfl
state_before: ι : Type u_1
M : Type u_2
n : ℕ
J✝ : Box ι
i : ι
x : ℝ
J : Box ι
h : x ∉ Ioo (J.lower i) (J.upper i)
hJ : J ∈ ⊤.boxes
⊢ J ∈ (split J i x).boxes
state_after: ι : Type u_1
M : Type u_2
n : ℕ
J✝ : Box ι
i : ι
x : ℝ
J : Box ι
h : x ∉ Ioo (J.lower i) (J.upper i)
⊢ J ∈ (split J i x).boxes
tactic: clear hJ
state_before: ι : Type u_1
M : Type u_2
n : ℕ
J✝ : Box ι
i : ι
x : ℝ
J : Box ι
h : x ∉ Ioo (J.lower i) (J.upper i)
⊢ J ∈ (split J i x).boxes
state_after: ι : Type u_1
M : Type u_2
n : ℕ
J✝ : Box ι
i : ι
x : ℝ
J : Box ι
h : x ∉ Ioo (J.lower i) (J.upper i)
⊢ ↑J = J.splitLower i x ∨ ↑J = J.splitUpper i x
tactic: rw [mem_boxes, mem_split_iff]
state_before: ι : Type u_1
M : Type u_2
n : ℕ
J✝ : Box ι
i : ι
x : ℝ
J : Box ι
h : x ∉ Ioo (J.lower i) (J.upper i)
⊢ ↑J = J.splitLower i x ∨ ↑J = J.splitUpper i x
state_after: ι : Type u_1
M : Type u_2
n : ℕ
J✝ : Box ι
i : ι
x : ℝ
J : Box ι
h : x ≤ J.lower i ∨ J.upper i ≤ x
⊢ ↑J = J.splitLower i x ∨ ↑J = J.splitUpper i x
tactic: rw [mem_Ioo, not_and_or, not_lt, not_lt] at h
state_before: ι : Type u_1
M : Type u_2
n : ℕ
J✝ : Box ι
i : ι
x : ℝ
J : Box ι
h : x ≤ J.lower i ∨ J.upper i ≤ x
⊢ ↑J = J.splitLower i x ∨ ↑J = J.splitUpper i x
state_after: case inl.h
ι : Type u_1
M : Type u_2
n : ℕ
J✝ : Box ι
i : ι
x : ℝ
J : Box ι
h✝ : x ≤ J.lower i
⊢ ↑J = J.splitUpper i x

case inr.h
ι : Type u_1
M : Type u_2
n : ℕ
J✝ : Box ι
i : ι
x : ℝ
J : Box ι
h✝ : J.upper i ≤ x
⊢ ↑J = J.splitLower i x
tactic: cases h <;> [right; left]
Theorem: intervalIntegrable_iff'
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝¹ : NormedAddCommGroup E
f : ℝ → E
a b : ℝ
μ : Measure ℝ
inst✝ : NoAtoms μ
⊢ IntervalIntegrable f μ a b ↔ IntegrableOn f [[a, b]] μ
state_after: no goals
tactic: rw [intervalIntegrable_iff, ← Icc_min_max, uIoc, integrableOn_Icc_iff_integrableOn_Ioc]
Theorem: toIocMod_add_toIcoMod_zero
File: Mathlib/Algebra/Order/ToIntervalMod.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIocMod hp 0 (a - b) + toIcoMod hp 0 (b - a) = p
state_after: no goals
tactic: rw [_root_.add_comm, toIcoMod_add_toIocMod_zero]
Theorem: CategoryTheory.Functor.mem_homologicalKernel_iff
File: Mathlib/CategoryTheory/Triangulated/HomologicalFunctor.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
A : Type u_3
inst✝¹⁶ : Category.{u_4, u_1} C
inst✝¹⁵ : HasZeroObject C
inst✝¹⁴ : HasShift C ℤ
inst✝¹³ : Preadditive C
inst✝¹² : ∀ (n : ℤ), (shiftFunctor C n).Additive
inst✝¹¹ : Pretriangulated C
inst✝¹⁰ : Category.{?u.18320, u_2} D
inst✝⁹ : HasZeroObject D
inst✝⁸ : HasShift D ℤ
inst✝⁷ : Preadditive D
inst✝⁶ : ∀ (n : ℤ), (shiftFunctor D n).Additive
inst✝⁵ : Pretriangulated D
inst✝⁴ : Category.{u_5, u_3} A
inst✝³ : Abelian A
F : C ⥤ A
inst✝² inst✝¹ : F.IsHomological
inst✝ : F.ShiftSequence ℤ
X : C
⊢ F.homologicalKernel.P X ↔ ∀ (n : ℤ), IsZero ((F.shift n).obj X)
state_after: C : Type u_1
D : Type u_2
A : Type u_3
inst✝¹⁶ : Category.{u_4, u_1} C
inst✝¹⁵ : HasZeroObject C
inst✝¹⁴ : HasShift C ℤ
inst✝¹³ : Preadditive C
inst✝¹² : ∀ (n : ℤ), (shiftFunctor C n).Additive
inst✝¹¹ : Pretriangulated C
inst✝¹⁰ : Category.{?u.18320, u_2} D
inst✝⁹ : HasZeroObject D
inst✝⁸ : HasShift D ℤ
inst✝⁷ : Preadditive D
inst✝⁶ : ∀ (n : ℤ), (shiftFunctor D n).Additive
inst✝⁵ : Pretriangulated D
inst✝⁴ : Category.{u_5, u_3} A
inst✝³ : Abelian A
F : C ⥤ A
inst✝² inst✝¹ : F.IsHomological
inst✝ : F.ShiftSequence ℤ
X : C
⊢ F.homologicalKernel.P X ↔ ∀ (n : ℤ), IsZero ((shiftFunctor C n ⋙ F).obj X)
tactic: simp only [← fun (n : ℤ) => Iso.isZero_iff ((F.isoShift n).app X)]
state_before: C : Type u_1
D : Type u_2
A : Type u_3
inst✝¹⁶ : Category.{u_4, u_1} C
inst✝¹⁵ : HasZeroObject C
inst✝¹⁴ : HasShift C ℤ
inst✝¹³ : Preadditive C
inst✝¹² : ∀ (n : ℤ), (shiftFunctor C n).Additive
inst✝¹¹ : Pretriangulated C
inst✝¹⁰ : Category.{?u.18320, u_2} D
inst✝⁹ : HasZeroObject D
inst✝⁸ : HasShift D ℤ
inst✝⁷ : Preadditive D
inst✝⁶ : ∀ (n : ℤ), (shiftFunctor D n).Additive
inst✝⁵ : Pretriangulated D
inst✝⁴ : Category.{u_5, u_3} A
inst✝³ : Abelian A
F : C ⥤ A
inst✝² inst✝¹ : F.IsHomological
inst✝ : F.ShiftSequence ℤ
X : C
⊢ F.homologicalKernel.P X ↔ ∀ (n : ℤ), IsZero ((shiftFunctor C n ⋙ F).obj X)
state_after: no goals
tactic: rfl
Theorem: SameRay.norm_smul_eq
File: Mathlib/Analysis/Normed/Module/Ray.lean

Proof steps:
state_before: E : Type u_1
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
x y : E
h : SameRay ℝ x y
⊢ ‖x‖ • y = ‖y‖ • x
state_after: case intro.intro.intro.intro.intro.intro.intro
E : Type u_1
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
u : E
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
h : SameRay ℝ (a • u) (b • u)
⊢ ‖a • u‖ • b • u = ‖b • u‖ • a • u
tactic: rcases h.exists_eq_smul with ⟨u, a, b, ha, hb, -, rfl, rfl⟩
state_before: case intro.intro.intro.intro.intro.intro.intro
E : Type u_1
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
u : E
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
h : SameRay ℝ (a • u) (b • u)
⊢ ‖a • u‖ • b • u = ‖b • u‖ • a • u
state_after: case intro.intro.intro.intro.intro.intro.intro
E : Type u_1
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
u : E
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
h : SameRay ℝ (a • u) (b • u)
⊢ a • ‖u‖ • b • u = b • ‖u‖ • a • u
tactic: simp only [norm_smul_of_nonneg, *, mul_smul]
state_before: case intro.intro.intro.intro.intro.intro.intro
E : Type u_1
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
u : E
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
h : SameRay ℝ (a • u) (b • u)
⊢ a • ‖u‖ • b • u = b • ‖u‖ • a • u
state_after: no goals
tactic: rw [smul_comm, smul_comm b, smul_comm a b u]
Theorem: gcd_isUnit_iff
File: Mathlib/RingTheory/PrincipalIdealDomain.lean

Proof steps:
state_before: R : Type u
M : Type v
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : IsBezout R
inst✝ : GCDMonoid R
x y : R
⊢ IsUnit (gcd x y) ↔ IsCoprime x y
state_after: no goals
tactic: rw [IsCoprime, ← Ideal.mem_span_pair, ← span_gcd, ← span_singleton_eq_top, eq_top_iff_one]
Theorem: accPt_iff_frequently
File: Mathlib/Topology/Basic.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x✝ : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
x : X
C : Set X
⊢ AccPt x (𝓟 C) ↔ ∃ᶠ (y : X) in 𝓝 x, y ≠ x ∧ y ∈ C
state_after: no goals
tactic: simp [acc_principal_iff_cluster, clusterPt_principal_iff_frequently, and_comm]
Theorem: Polynomial.ofFinsupp_add
File: Mathlib/Algebra/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
a✝ b✝ : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
a b : R[ℕ]
⊢ { toFinsupp := a + b } = Polynomial.add { toFinsupp := a } { toFinsupp := b }
state_after: no goals
tactic: rw [add_def]
Theorem: Part.append_mem_append
File: Mathlib/Data/Part.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Append α
a b : Part α
ma mb : α
ha : ma ∈ a
hb : mb ∈ b
⊢ ma ++ mb ∈ a ++ b
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Append α
a b : Part α
ma mb : α
ha : ma ∈ a
hb : mb ∈ b
⊢ ∃ a_1 ∈ a, ∃ a ∈ b, a_1 ++ a = ma ++ mb
tactic: simp [append_def]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Append α
a b : Part α
ma mb : α
ha : ma ∈ a
hb : mb ∈ b
⊢ ∃ a_1 ∈ a, ∃ a ∈ b, a_1 ++ a = ma ++ mb
state_after: no goals
tactic: aesop
Theorem: Primrec.of_equiv_symm
File: Mathlib/Computability/Primrec.lean

Proof steps:
state_before: α : Type u_1
β✝ : Type u_2
σ : Type u_3
inst✝² : Primcodable α
inst✝¹ : Primcodable β✝
inst✝ : Primcodable σ
β : Type u_4
e : β ≃ α
this : Primcodable β := Primcodable.ofEquiv α e
⊢ Primrec fun a => encode (e (e.symm a))
state_after: no goals
tactic: simp [Primrec.encode]
Theorem: Polynomial.integralNormalization_coeff
File: Mathlib/RingTheory/Polynomial/IntegralNormalization.lean

Proof steps:
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
f : R[X]
i : ℕ
⊢ f.integralNormalization.coeff i = if f.degree = ↑i then 1 else f.coeff i * f.leadingCoeff ^ (f.natDegree - 1 - i)
state_after: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
f : R[X]
i : ℕ
this : f.coeff i = 0 → f.degree ≠ ↑i
⊢ f.integralNormalization.coeff i = if f.degree = ↑i then 1 else f.coeff i * f.leadingCoeff ^ (f.natDegree - 1 - i)
tactic: have : f.coeff i = 0 → f.degree ≠ i := fun hc hd => coeff_ne_zero_of_eq_degree hd hc
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
f : R[X]
i : ℕ
this : f.coeff i = 0 → f.degree ≠ ↑i
⊢ f.integralNormalization.coeff i = if f.degree = ↑i then 1 else f.coeff i * f.leadingCoeff ^ (f.natDegree - 1 - i)
state_after: no goals
tactic: simp (config := { contextual := true }) [integralNormalization, coeff_monomial, this,
    mem_support_iff]
Theorem: CategoryTheory.Square.toArrowArrowFunctor_map_left_right
File: Mathlib/CategoryTheory/Square.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : Square C
φ : X✝ ⟶ Y✝
⊢ Arrow.homMk ⋯ ≫ ((fun sq => Arrow.mk (Arrow.homMk ⋯)) Y✝).hom =
    ((fun sq => Arrow.mk (Arrow.homMk ⋯)) X✝).hom ≫ Arrow.homMk ⋯
state_after: no goals
tactic: aesop_cat
Theorem: Sum.getRight?_swap
File: .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
x : α ⊕ β
⊢ x.swap.getRight? = x.getLeft?
state_after: no goals
tactic: cases x <;> rfl
Theorem: Comon_.Mon_OpOpToComon_obj'_X
File: Mathlib/CategoryTheory/Monoidal/Comon_.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M : Comon_ C
A : Mon_ Cᵒᵖ
⊢ A.mul.unop ≫ A.one.unop ▷ unop A.X = (λ_ (unop A.X)).inv
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M : Comon_ C
A : Mon_ Cᵒᵖ
⊢ (λ_ A.X).hom.unop = (λ_ (unop A.X)).inv
tactic: rw [← unop_whiskerRight, ← unop_comp, Mon_.one_mul]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M : Comon_ C
A : Mon_ Cᵒᵖ
⊢ (λ_ A.X).hom.unop = (λ_ (unop A.X)).inv
state_after: no goals
tactic: rfl
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M : Comon_ C
A : Mon_ Cᵒᵖ
⊢ A.mul.unop ≫ unop A.X ◁ A.one.unop = (ρ_ (unop A.X)).inv
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M : Comon_ C
A : Mon_ Cᵒᵖ
⊢ (ρ_ A.X).hom.unop = (ρ_ (unop A.X)).inv
tactic: rw [← unop_whiskerLeft, ← unop_comp, Mon_.mul_one]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M : Comon_ C
A : Mon_ Cᵒᵖ
⊢ (ρ_ A.X).hom.unop = (ρ_ (unop A.X)).inv
state_after: no goals
tactic: rfl
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M : Comon_ C
A : Mon_ Cᵒᵖ
⊢ A.mul.unop ≫ unop A.X ◁ A.mul.unop = A.mul.unop ≫ A.mul.unop ▷ unop A.X ≫ (α_ (unop A.X) (unop A.X) (unop A.X)).hom
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M : Comon_ C
A : Mon_ Cᵒᵖ
⊢ ((α_ A.X A.X A.X).inv ≫ A.mul ▷ A.X ≫ A.mul).unop =
    (A.mul ▷ A.X ≫ A.mul).unop ≫ (α_ (unop A.X) (unop A.X) (unop A.X)).hom
tactic: rw [← unop_whiskerRight, ← unop_whiskerLeft, ← unop_comp_assoc, ← unop_comp,
      Mon_.mul_assoc_flip]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M : Comon_ C
A : Mon_ Cᵒᵖ
⊢ ((α_ A.X A.X A.X).inv ≫ A.mul ▷ A.X ≫ A.mul).unop =
    (A.mul ▷ A.X ≫ A.mul).unop ≫ (α_ (unop A.X) (unop A.X) (unop A.X)).hom
state_after: no goals
tactic: rfl
Theorem: GromovHausdorff.HD_candidatesBDist_le
File: Mathlib/Topology/MetricSpace/GromovHausdorffRealized.lean

Proof steps:
state_before: X : Type u
Y : Type v
inst✝⁵ : MetricSpace X
inst✝⁴ : CompactSpace X
inst✝³ : Nonempty X
inst✝² : MetricSpace Y
inst✝¹ : CompactSpace Y
inst✝ : Nonempty Y
f : GromovHausdorff.ProdSpaceFun X Y
x y z t : X ⊕ Y
⊢ HD (candidatesBDist X Y) ≤ diam univ + 1 + diam univ
state_after: case refine_1
X : Type u
Y : Type v
inst✝⁵ : MetricSpace X
inst✝⁴ : CompactSpace X
inst✝³ : Nonempty X
inst✝² : MetricSpace Y
inst✝¹ : CompactSpace Y
inst✝ : Nonempty Y
f : GromovHausdorff.ProdSpaceFun X Y
x✝ y z t : X ⊕ Y
x : X
⊢ ⨅ y, (candidatesBDist X Y) (inl x, inr y) ≤ diam univ + 1 + diam univ

case refine_2
X : Type u
Y : Type v
inst✝⁵ : MetricSpace X
inst✝⁴ : CompactSpace X
inst✝³ : Nonempty X
inst✝² : MetricSpace Y
inst✝¹ : CompactSpace Y
inst✝ : Nonempty Y
f : GromovHausdorff.ProdSpaceFun X Y
x y✝ z t : X ⊕ Y
y : Y
⊢ ⨅ x, (candidatesBDist X Y) (inl x, inr y) ≤ diam univ + 1 + diam univ
tactic: refine max_le (ciSup_le fun x => ?_) (ciSup_le fun y => ?_)
Theorem: Submodule.finrank_add_finrank_le_of_disjoint
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

Proof steps:
state_before: K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
s t : Submodule K V
hdisjoint : Disjoint s t
⊢ finrank K ↥s + finrank K ↥t ≤ finrank K V
state_after: K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
s t : Submodule K V
hdisjoint : Disjoint s t
⊢ finrank K ↥(s ⊔ t) ≤ finrank K V
tactic: rw [← Submodule.finrank_sup_add_finrank_inf_eq s t, hdisjoint.eq_bot, finrank_bot, add_zero]
state_before: K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
s t : Submodule K V
hdisjoint : Disjoint s t
⊢ finrank K ↥(s ⊔ t) ≤ finrank K V
state_after: no goals
tactic: exact Submodule.finrank_le _
Theorem: Finset.mulETransformRight.card
File: Mathlib/Combinatorics/Additive/ETransform.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Group α
e : α
x : Finset α × Finset α
⊢ x.2.card + (e⁻¹ • x.2).card = 2 * x.2.card
state_after: no goals
tactic: rw [card_smul_finset, two_mul]
Theorem: SetTheory.PGame.moveRight_nim
File: Mathlib/SetTheory/Game/Nim.lean

Proof steps:
state_before: o : Ordinal.{u_1}
i : ↑(Set.Iio o)
⊢ (nim o).moveRight (toRightMovesNim i) = nim ↑i
state_after: no goals
tactic: simp
Theorem: SimpleGraph.CliqueFreeOn.of_succ
File: Mathlib/Combinatorics/SimpleGraph/Clique.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G H : SimpleGraph α
s s₁ s₂ : Set α
t : Finset α
a b : α
m n : ℕ
hs : G.CliqueFreeOn s (n + 1)
ha : a ∈ s
⊢ G.CliqueFreeOn (s ∩ G.neighborSet a) n
state_after: no goals
tactic: classical
  refine fun t hts ht => hs ?_ (ht.insert fun b hb => (hts hb).2)
  push_cast
  exact Set.insert_subset_iff.2 ⟨ha, hts.trans Set.inter_subset_left⟩
Theorem: Order.Ico_pred_right_eq_insert
File: Mathlib/Order/SuccPred/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : PartialOrder α
inst✝¹ : PredOrder α
a b : α
inst✝ : NoMinOrder α
h : a ≤ b
⊢ Ioc (pred a) b = insert a (Ioc a b)
state_after: no goals
tactic: simp_rw [← Ioi_inter_Iic, Ioi_pred_eq_insert, insert_inter_of_mem (mem_Iic.2 h)]
Theorem: CategoryTheory.Iso.cancel_iso_inv_right_assoc
File: Mathlib/CategoryTheory/Iso.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ Z✝ W X X' Y Z : C
f : W ⟶ X
g : X ⟶ Y
f' : W ⟶ X'
g' : X' ⟶ Y
h : Z ≅ Y
⊢ f ≫ g ≫ h.inv = f' ≫ g' ≫ h.inv ↔ f ≫ g = f' ≫ g'
state_after: no goals
tactic: simp only [← Category.assoc, cancel_mono]
Theorem: LipschitzOnWith.extend_lp_infty
File: Mathlib/Topology/MetricSpace/Kuratowski.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝ : PseudoMetricSpace α
s : Set α
ι : Type u_1
f : α → ↥(lp (fun i => ℝ) ⊤)
K : ℝ≥0
hfl : LipschitzOnWith K f s
⊢ ∃ g, LipschitzWith K g ∧ EqOn f g s
state_after: α : Type u
β : Type v
γ : Type w
inst✝ : PseudoMetricSpace α
s : Set α
ι : Type u_1
f : α → ↥(lp (fun i => ℝ) ⊤)
K : ℝ≥0
hfl : ∀ (i : ι), LipschitzOnWith K (fun a => ↑(f a) i) s
⊢ ∃ g, LipschitzWith K g ∧ EqOn f g s
tactic: rw [LipschitzOnWith.coordinate] at hfl
state_before: α : Type u
β : Type v
γ : Type w
inst✝ : PseudoMetricSpace α
s : Set α
ι : Type u_1
f : α → ↥(lp (fun i => ℝ) ⊤)
K : ℝ≥0
hfl : ∀ (i : ι), LipschitzOnWith K (fun a => ↑(f a) i) s
⊢ ∃ g, LipschitzWith K g ∧ EqOn f g s
state_after: α : Type u
β : Type v
γ : Type w
inst✝ : PseudoMetricSpace α
s : Set α
ι : Type u_1
f : α → ↥(lp (fun i => ℝ) ⊤)
K : ℝ≥0
hfl : ∀ (i : ι), LipschitzOnWith K (fun a => ↑(f a) i) s
this : ∀ (i : ι), ∃ g, LipschitzWith K g ∧ EqOn (fun x => ↑(f x) i) g s
⊢ ∃ g, LipschitzWith K g ∧ EqOn f g s
tactic: have (i : ι) : ∃ g : α → ℝ, LipschitzWith K g ∧ EqOn (fun x => f x i) g s :=
    LipschitzOnWith.extend_real (hfl i)
state_before: α : Type u
β : Type v
γ : Type w
inst✝ : PseudoMetricSpace α
s : Set α
ι : Type u_1
f : α → ↥(lp (fun i => ℝ) ⊤)
K : ℝ≥0
hfl : ∀ (i : ι), LipschitzOnWith K (fun a => ↑(f a) i) s
this : ∀ (i : ι), ∃ g, LipschitzWith K g ∧ EqOn (fun x => ↑(f x) i) g s
⊢ ∃ g, LipschitzWith K g ∧ EqOn f g s
state_after: α : Type u
β : Type v
γ : Type w
inst✝ : PseudoMetricSpace α
s : Set α
ι : Type u_1
f : α → ↥(lp (fun i => ℝ) ⊤)
K : ℝ≥0
hfl : ∀ (i : ι), LipschitzOnWith K (fun a => ↑(f a) i) s
g : ι → α → ℝ
hgl : ∀ (i : ι), LipschitzWith K (g i)
hgeq : ∀ (i : ι), EqOn (fun x => ↑(f x) i) (g i) s
⊢ ∃ g, LipschitzWith K g ∧ EqOn f g s
tactic: choose g hgl hgeq using this
state_before: α : Type u
β : Type v
γ : Type w
inst✝ : PseudoMetricSpace α
s : Set α
ι : Type u_1
f : α → ↥(lp (fun i => ℝ) ⊤)
K : ℝ≥0
hfl : ∀ (i : ι), LipschitzOnWith K (fun a => ↑(f a) i) s
g : ι → α → ℝ
hgl : ∀ (i : ι), LipschitzWith K (g i)
hgeq : ∀ (i : ι), EqOn (fun x => ↑(f x) i) (g i) s
⊢ ∃ g, LipschitzWith K g ∧ EqOn f g s
state_after: case inl
α : Type u
β : Type v
γ : Type w
inst✝ : PseudoMetricSpace α
ι : Type u_1
f : α → ↥(lp (fun i => ℝ) ⊤)
K : ℝ≥0
g : ι → α → ℝ
hgl : ∀ (i : ι), LipschitzWith K (g i)
hfl : ∀ (i : ι), LipschitzOnWith K (fun a => ↑(f a) i) ∅
hgeq : ∀ (i : ι), EqOn (fun x => ↑(f x) i) (g i) ∅
⊢ ∃ g, LipschitzWith K g ∧ EqOn f g ∅

case inr.intro
α : Type u
β : Type v
γ : Type w
inst✝ : PseudoMetricSpace α
s : Set α
ι : Type u_1
f : α → ↥(lp (fun i => ℝ) ⊤)
K : ℝ≥0
hfl : ∀ (i : ι), LipschitzOnWith K (fun a => ↑(f a) i) s
g : ι → α → ℝ
hgl : ∀ (i : ι), LipschitzWith K (g i)
hgeq : ∀ (i : ι), EqOn (fun x => ↑(f x) i) (g i) s
a₀ : α
ha₀_in_s : a₀ ∈ s
⊢ ∃ g, LipschitzWith K g ∧ EqOn f g s
tactic: rcases s.eq_empty_or_nonempty with rfl | ⟨a₀, ha₀_in_s⟩
Theorem: Int.ball_eq_Ioo
File: Mathlib/Topology/Instances/Int.lean

Proof steps:
state_before: x : ℤ
r : ℝ
⊢ ball x r = Ioo ⌊↑x - r⌋ ⌈↑x + r⌉
state_after: no goals
tactic: rw [← preimage_ball, Real.ball_eq_Ioo, preimage_Ioo]
Theorem: summable_powerSeries_of_norm_lt_one
File: Mathlib/Analysis/SpecificLimits/Normed.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝¹ : NormedDivisionRing α
inst✝ : CompleteSpace α
f : ℕ → α
z : α
h : CauchySeq fun n => ∑ i ∈ Finset.range n, f i
hz : ‖z‖ < 1
⊢ CauchySeq fun n => ∑ i ∈ Finset.range n, f i * 1 ^ i
state_after: no goals
tactic: simp [h]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝¹ : NormedDivisionRing α
inst✝ : CompleteSpace α
f : ℕ → α
z : α
h : CauchySeq fun n => ∑ i ∈ Finset.range n, f i
hz : ‖z‖ < 1
⊢ ‖z‖ < ‖1‖
state_after: no goals
tactic: simp [hz]
Theorem: NNReal.tendsto_const_div_atTop_nhds_zero_nat
File: Mathlib/Analysis/SpecificLimits/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
C : ℝ≥0
⊢ Tendsto (fun n => C / ↑n) atTop (𝓝 0)
state_after: no goals
tactic: simpa using tendsto_const_nhds.mul NNReal.tendsto_inverse_atTop_nhds_zero_nat
Theorem: le_inv_smul_iff_of_pos
File: Mathlib/Algebra/Order/Module/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
a a₁ a₂ : α
b b₁ b₂ : β
inst✝⁵ : GroupWithZero α
inst✝⁴ : Preorder α
inst✝³ : Preorder β
inst✝² : MulAction α β
inst✝¹ : PosSMulMono α β
inst✝ : PosSMulReflectLE α β
ha : 0 < a
⊢ b₁ ≤ a⁻¹ • b₂ ↔ a • b₁ ≤ b₂
state_after: no goals
tactic: rw [← smul_le_smul_iff_of_pos_left ha, smul_inv_smul₀ ha.ne']