ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Submonoid.LocalizationMap.map_mul_left
File: Mathlib/GroupTheory/MonoidLocalization/Basic.lean

Proof steps:
state_before: M : Type u_1
inst✝³ : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝² : CommMonoid N
P : Type u_3
inst✝¹ : CommMonoid P
f : S.LocalizationMap N
g : M →* P
hg : ∀ (y : ↥S), IsUnit (g ↑y)
T : Submonoid P
hy : ∀ (y : ↥S), g ↑y ∈ T
Q : Type u_4
inst✝ : CommMonoid Q
k : T.LocalizationMap Q
z : N
⊢ k.toMap (g ↑(f.sec z).2) * (f.map hy k) z = k.toMap (g (f.sec z).1)
state_after: no goals
tactic: rw [mul_comm, f.map_mul_right]
Theorem: Primrec.dom_bool
File: Mathlib/Computability/Primrec.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
σ : Type u_5
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable δ
inst✝ : Primcodable σ
f : Bool → α
b : Bool
⊢ (bif id b then f true else f false) = f b
state_after: no goals
tactic: cases b <;> rfl
Theorem: Mathlib.Meta.NormNum.isNat_natCast
File: Mathlib/Tactic/NormNum/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝ : AddMonoidWithOne R
n m : ℕ
⊢ IsNat n m → IsNat (↑n) m
state_after: case mk.refl
R : Type u_1
inst✝ : AddMonoidWithOne R
m : ℕ
⊢ IsNat (↑↑m) m
tactic: rintro ⟨⟨⟩⟩
state_before: case mk.refl
R : Type u_1
inst✝ : AddMonoidWithOne R
m : ℕ
⊢ IsNat (↑↑m) m
state_after: no goals
tactic: exact ⟨rfl⟩
Theorem: nhdsWithin_Ioi_eq_bot_iff
File: Mathlib/Topology/Order/LeftRightNhds.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
a : α
⊢ 𝓝[>] a = ⊥ ↔ IsTop a ∨ ∃ b, a ⋖ b
state_after: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
a : α
ha : IsTop a
⊢ 𝓝[>] a = ⊥ ↔ IsTop a ∨ ∃ b, a ⋖ b

case neg
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
a : α
ha : ¬IsTop a
⊢ 𝓝[>] a = ⊥ ↔ IsTop a ∨ ∃ b, a ⋖ b
tactic: by_cases ha : IsTop a
Theorem: CategoryTheory.Presieve.isSheafFor_top_sieve
File: Mathlib/CategoryTheory/Sites/IsSheafFor.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P✝ Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
P : Cᵒᵖ ⥤ Type w
⊢ IsSheafFor P ⊤.arrows
state_after: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P✝ Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
P : Cᵒᵖ ⥤ Type w
⊢ IsSheafFor P (generate (singleton (𝟙 X))).arrows
tactic: rw [← generate_of_singleton_isSplitEpi (𝟙 X)]
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P✝ Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
P : Cᵒᵖ ⥤ Type w
⊢ IsSheafFor P (generate (singleton (𝟙 X))).arrows
state_after: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P✝ Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
P : Cᵒᵖ ⥤ Type w
⊢ IsSheafFor P (singleton (𝟙 X))
tactic: rw [← isSheafFor_iff_generate]
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P✝ Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
P : Cᵒᵖ ⥤ Type w
⊢ IsSheafFor P (singleton (𝟙 X))
state_after: no goals
tactic: apply isSheafFor_singleton_iso
Theorem: Batteries.RBSet.ModifyWF.of_eq
File: .lake/packages/batteries/Batteries/Data/RBMap/Alter.lean

Proof steps:
state_before: α : Type u_1
cmp : α → α → Ordering
cut : α → Ordering
f : α → α
t : RBSet α cmp
H : ∀ {x : α}, RBNode.find? cut t.val = some x → cmpEq cmp (f x) x
⊢ t.ModifyWF cut f
state_after: α : Type u_1
cmp : α → α → Ordering
cut : α → Ordering
f : α → α
t : RBSet α cmp
H : ∀ {x : α}, RBNode.find? cut t.val = some x → cmpEq cmp (f x) x
⊢ OnRoot (fun x => cmpEq cmp (f x) x) (zoom cut t.val).fst
tactic: refine ⟨.modify ?_ t.2⟩
state_before: α : Type u_1
cmp : α → α → Ordering
cut : α → Ordering
f : α → α
t : RBSet α cmp
H : ∀ {x : α}, RBNode.find? cut t.val = some x → cmpEq cmp (f x) x
⊢ OnRoot (fun x => cmpEq cmp (f x) x) (zoom cut t.val).fst
state_after: α : Type u_1
cmp : α → α → Ordering
cut : α → Ordering
f : α → α
t : RBSet α cmp
⊢ (∀ {x : α}, RBNode.find? cut t.val = some x → cmpEq cmp (f x) x) →
    OnRoot (fun x => cmpEq cmp (f x) x) (zoom cut t.val).fst
tactic: revert H
state_before: α : Type u_1
cmp : α → α → Ordering
cut : α → Ordering
f : α → α
t : RBSet α cmp
⊢ (∀ {x : α}, RBNode.find? cut t.val = some x → cmpEq cmp (f x) x) →
    OnRoot (fun x => cmpEq cmp (f x) x) (zoom cut t.val).fst
state_after: α : Type u_1
cmp : α → α → Ordering
cut : α → Ordering
f : α → α
t : RBSet α cmp
⊢ (∀ {x : α}, (zoom cut t.val).fst.root? = some x → cmpEq cmp (f x) x) →
    OnRoot (fun x => cmpEq cmp (f x) x) (zoom cut t.val).fst
tactic: rw [find?_eq_zoom]
state_before: α : Type u_1
cmp : α → α → Ordering
cut : α → Ordering
f : α → α
t : RBSet α cmp
⊢ (∀ {x : α}, (zoom cut t.val).fst.root? = some x → cmpEq cmp (f x) x) →
    OnRoot (fun x => cmpEq cmp (f x) x) (zoom cut t.val).fst
state_after: no goals
tactic: cases (t.1.zoom cut).1 <;> intro H <;> [trivial; exact H rfl]
Theorem: Sym2.other_ne
File: Mathlib/Data/Sym/Sym2.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
a : α
z : Sym2 α
hd : ¬z.IsDiag
h : a ∈ z
⊢ Mem.other h ≠ a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
a : α
z : Sym2 α
h : a ∈ z
hd : Mem.other h = a
⊢ z.IsDiag
tactic: contrapose! hd
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
a : α
z : Sym2 α
h : a ∈ z
hd : Mem.other h = a
⊢ z.IsDiag
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
a : α
z : Sym2 α
h : a ∈ z
hd : Mem.other h = a
h' : s(a, Mem.other h) = z
⊢ z.IsDiag
tactic: have h' := Sym2.other_spec h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
a : α
z : Sym2 α
h : a ∈ z
hd : Mem.other h = a
h' : s(a, Mem.other h) = z
⊢ z.IsDiag
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
a : α
z : Sym2 α
h : a ∈ z
hd : Mem.other h = a
h' : s(a, a) = z
⊢ z.IsDiag
tactic: rw [hd] at h'
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
a : α
z : Sym2 α
h : a ∈ z
hd : Mem.other h = a
h' : s(a, a) = z
⊢ z.IsDiag
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
a : α
z : Sym2 α
h : a ∈ z
hd : Mem.other h = a
h' : s(a, a) = z
⊢ s(a, a).IsDiag
tactic: rw [← h']
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
a : α
z : Sym2 α
h : a ∈ z
hd : Mem.other h = a
h' : s(a, a) = z
⊢ s(a, a).IsDiag
state_after: no goals
tactic: simp
Theorem: MeasureTheory.VectorMeasure.ennrealToMeasure_toENNRealVectorMeasure
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ : Measure α
s : Set α
hs : MeasurableSet s
⊢ μ.toENNRealVectorMeasure.ennrealToMeasure s = μ s
state_after: no goals
tactic: rw [ennrealToMeasure_apply hs, toENNRealVectorMeasure_apply_measurable hs]
Theorem: GenContFract.partNum_eq_s_a
File: Mathlib/Algebra/ContinuedFractions/Translations.lean

Proof steps:
state_before: α : Type u_1
g : GenContFract α
n : ℕ
gp : Pair α
s_nth_eq : g.s.get? n = some gp
⊢ g.partNums.get? n = some gp.a
state_after: no goals
tactic: simp [partNums, s_nth_eq]
Theorem: Real.Angle.tan_periodic
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

Proof steps:
state_before: ⊢ Function.Periodic tan ↑π
state_after: θ : Angle
⊢ (θ + ↑π).tan = θ.tan
tactic: intro θ
state_before: θ : Angle
⊢ (θ + ↑π).tan = θ.tan
state_after: case h
x✝ : ℝ
⊢ (↑x✝ + ↑π).tan = (↑x✝).tan
tactic: induction θ using Real.Angle.induction_on
state_before: case h
x✝ : ℝ
⊢ (↑x✝ + ↑π).tan = (↑x✝).tan
state_after: case h
x✝ : ℝ
⊢ Real.tan (x✝ + π) = Real.tan x✝
tactic: rw [← coe_add, tan_coe, tan_coe]
state_before: case h
x✝ : ℝ
⊢ Real.tan (x✝ + π) = Real.tan x✝
state_after: no goals
tactic: exact Real.tan_periodic _
Theorem: Option.isNone_eq_false_iff
File: Mathlib/Data/Option/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a : Option α
⊢ a.isNone = false ↔ a.isSome = true
state_after: no goals
tactic: cases a <;> simp
Theorem: CategoryTheory.InjectiveResolution.toRightDerivedZero'_naturality
File: Mathlib/CategoryTheory/Abelian/RightDerived.lean

Proof steps:
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u_1
inst✝⁴ : Category.{u_2, u_1} D
inst✝³ : Abelian C
inst✝² : HasInjectiveResolutions C
inst✝¹ : Abelian D
X Y : C
f : X ⟶ Y
P : InjectiveResolution X
Q : InjectiveResolution Y
φ : P.cocomplex ⟶ Q.cocomplex
comm : P.ι.f 0 ≫ φ.f 0 = f ≫ Q.ι.f 0
F : C ⥤ D
inst✝ : F.Additive
⊢ F.map f ≫ Q.toRightDerivedZero' F =
    P.toRightDerivedZero' F ≫ HomologicalComplex.cyclesMap ((F.mapHomologicalComplex (ComplexShape.up ℕ)).map φ) 0
state_after: no goals
tactic: simp only [← cancel_mono (HomologicalComplex.iCycles _ _),
    Functor.mapHomologicalComplex_obj_X, assoc, toRightDerivedZero'_comp_iCycles,
    CochainComplex.single₀_obj_zero, HomologicalComplex.cyclesMap_i,
    Functor.mapHomologicalComplex_map_f, toRightDerivedZero'_comp_iCycles_assoc,
    ← F.map_comp, comm]
Theorem: mul_lt_mul_of_lt_of_le₀
File: Mathlib/Algebra/Order/GroupWithZero/Canonical.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedCommGroupWithZero α
a b c d : α
m n : ℕ
hab : a ≤ b
hb : b ≠ 0
hcd : c < d
hd : d ≠ 0
ha : a = 0
⊢ a * c < b * d
state_after: α : Type u_1
inst✝ : LinearOrderedCommGroupWithZero α
a b c d : α
m n : ℕ
hab : a ≤ b
hb : b ≠ 0
hcd : c < d
hd : d ≠ 0
ha : a = 0
⊢ b * d ≠ 0
tactic: rw [ha, zero_mul, zero_lt_iff]
state_before: α : Type u_1
inst✝ : LinearOrderedCommGroupWithZero α
a b c d : α
m n : ℕ
hab : a ≤ b
hb : b ≠ 0
hcd : c < d
hd : d ≠ 0
ha : a = 0
⊢ b * d ≠ 0
state_after: no goals
tactic: exact mul_ne_zero hb hd
state_before: α : Type u_1
inst✝ : LinearOrderedCommGroupWithZero α
a b c d : α
m n : ℕ
hab : a ≤ b
hb : b ≠ 0
hcd : c < d
hd : d ≠ 0
ha : ¬a = 0
hc : c = 0
⊢ a * c < b * d
state_after: α : Type u_1
inst✝ : LinearOrderedCommGroupWithZero α
a b c d : α
m n : ℕ
hab : a ≤ b
hb : b ≠ 0
hcd : c < d
hd : d ≠ 0
ha : ¬a = 0
hc : c = 0
⊢ b * d ≠ 0
tactic: rw [hc, mul_zero, zero_lt_iff]
state_before: α : Type u_1
inst✝ : LinearOrderedCommGroupWithZero α
a b c d : α
m n : ℕ
hab : a ≤ b
hb : b ≠ 0
hcd : c < d
hd : d ≠ 0
ha : ¬a = 0
hc : c = 0
⊢ b * d ≠ 0
state_after: no goals
tactic: exact mul_ne_zero hb hd
Theorem: Polynomial.one_lt_rootMultiplicity_iff_isRoot_gcd
File: Mathlib/Algebra/Polynomial/FieldDivision.lean

Proof steps:
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : GCDMonoid R[X]
p : R[X]
t : R
h : p ≠ 0
⊢ 1 < rootMultiplicity t p ↔ (gcd p (derivative p)).IsRoot t
state_after: no goals
tactic: simp_rw [one_lt_rootMultiplicity_iff_isRoot h, ← dvd_iff_isRoot, dvd_gcd_iff]
Theorem: CategoryTheory.Limits.WidePullbackShape.mkCone_pt
File: Mathlib/CategoryTheory/Limits/Shapes/WidePullbacks.lean

Proof steps:
state_before: J : Type w
C : Type u
inst✝ : Category.{v, u} C
F : WidePullbackShape J ⥤ C
X : C
f✝ : X ⟶ F.obj none
π : (j : J) → X ⟶ F.obj (some j)
w : ∀ (j : J), π j ≫ F.map (Hom.term j) = f✝
j j' : WidePullbackShape J
f : j ⟶ j'
⊢ ((Functor.const (WidePullbackShape J)).obj X).map f ≫
      (fun j =>
          match j with
          | none => f✝
          | some j => π j)
        j' =
    (fun j =>
          match j with
          | none => f✝
          | some j => π j)
        j ≫
      F.map f
state_after: no goals
tactic: cases j <;> cases j' <;> cases f <;> dsimp <;> simp [w]
Theorem: unitInterval.mem_iff_one_sub_mem
File: Mathlib/Topology/UnitInterval.lean

Proof steps:
state_before: t : ℝ
⊢ t ∈ I ↔ 1 - t ∈ I
state_after: t : ℝ
⊢ 0 ≤ t ∧ t ≤ 1 ↔ 0 ≤ 1 - t ∧ 1 - t ≤ 1
tactic: rw [mem_Icc, mem_Icc]
state_before: t : ℝ
⊢ 0 ≤ t ∧ t ≤ 1 ↔ 0 ≤ 1 - t ∧ 1 - t ≤ 1
state_after: no goals
tactic: constructor <;> intro <;> constructor <;> linarith
Theorem: WeierstrassCurve.Affine.CoordinateRing.map_mk
File: Mathlib/AlgebraicGeometry/EllipticCurve/Group.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
x : R[X][Y]
⊢ (map W f) ((mk W) x) = (mk (WeierstrassCurve.map W f)) (Polynomial.map (mapRingHom f) x)
state_after: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
x : R[X][Y]
⊢ eval₂ (AdjoinRoot.of (WeierstrassCurve.map W f).toAffine.polynomial)
      (AdjoinRoot.root (WeierstrassCurve.map W f).toAffine.polynomial) (Polynomial.map (mapRingHom f) x) =
    (mk (WeierstrassCurve.map W f)) (Polynomial.map (mapRingHom f) x)
tactic: rw [map, AdjoinRoot.lift_mk, ← eval₂_map]
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
x : R[X][Y]
⊢ eval₂ (AdjoinRoot.of (WeierstrassCurve.map W f).toAffine.polynomial)
      (AdjoinRoot.root (WeierstrassCurve.map W f).toAffine.polynomial) (Polynomial.map (mapRingHom f) x) =
    (mk (WeierstrassCurve.map W f)) (Polynomial.map (mapRingHom f) x)
state_after: no goals
tactic: exact AdjoinRoot.aeval_eq <| x.map <| mapRingHom f
Theorem: Real.tan_arccos
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

Proof steps:
state_before: x✝ y x : ℝ
⊢ tan (arccos x) = √(1 - x ^ 2) / x
state_after: no goals
tactic: rw [arccos, tan_pi_div_two_sub, tan_arcsin, inv_div]
Theorem: AlgebraicGeometry.Scheme.Spec_obj
File: Mathlib/AlgebraicGeometry/Scheme.lean

Proof steps:
state_before: R : CommRingCatᵒᵖ
⊢ { obj := fun R => Spec (unop R), map := fun {X Y} f => Spec.map f.unop }.map (𝟙 R) =
    𝟙 ({ obj := fun R => Spec (unop R), map := fun {X Y} f => Spec.map f.unop }.obj R)
state_after: no goals
tactic: simp
state_before: X✝ Y✝ Z✝ : CommRingCatᵒᵖ
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ { obj := fun R => Spec (unop R), map := fun {X Y} f => Spec.map f.unop }.map (f ≫ g) =
    { obj := fun R => Spec (unop R), map := fun {X Y} f => Spec.map f.unop }.map f ≫
      { obj := fun R => Spec (unop R), map := fun {X Y} f => Spec.map f.unop }.map g
state_after: no goals
tactic: simp
Theorem: Function.Periodic.mul_const'
File: Mathlib/Algebra/Periodic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝ : DivisionSemiring α
h : Periodic f c
a : α
⊢ Periodic (fun x => f (x * a)) (c / a)
state_after: no goals
tactic: simpa only [div_eq_mul_inv] using h.mul_const a
Theorem: Set.intersecting_iff_pairwise_not_disjoint
File: Mathlib/Combinatorics/SetFamily/Intersecting.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : SemilatticeInf α
inst✝ : OrderBot α
s t : Set α
a b c : α
⊢ s.Intersecting ↔ (s.Pairwise fun a b => ¬Disjoint a b) ∧ s ≠ {⊥}
state_after: case refine_1
α : Type u_1
inst✝¹ : SemilatticeInf α
inst✝ : OrderBot α
s t : Set α
a b c : α
h : s.Intersecting
⊢ s ≠ {⊥}

case refine_2
α : Type u_1
inst✝¹ : SemilatticeInf α
inst✝ : OrderBot α
s t : Set α
a✝ b✝ c : α
h : (s.Pairwise fun a b => ¬Disjoint a b) ∧ s ≠ {⊥}
a : α
ha : a ∈ s
b : α
hb : b ∈ s
hab : Disjoint a b
⊢ False
tactic: refine ⟨fun h => ⟨fun a ha b hb _ => h ha hb, ?_⟩, fun h a ha b hb hab => ?_⟩
state_before: case refine_2
α : Type u_1
inst✝¹ : SemilatticeInf α
inst✝ : OrderBot α
s t : Set α
a✝ b✝ c : α
h : (s.Pairwise fun a b => ¬Disjoint a b) ∧ s ≠ {⊥}
a : α
ha : a ∈ s
b : α
hb : b ∈ s
hab : Disjoint a b
⊢ False
state_after: case refine_2
α : Type u_1
inst✝¹ : SemilatticeInf α
inst✝ : OrderBot α
s t : Set α
a✝ b✝ c : α
h : (s.Pairwise fun a b => ¬Disjoint a b) ∧ s ≠ {⊥}
a : α
ha : a ∈ s
b : α
hb : b ∈ s
hab : Disjoint a b
this : a = b
⊢ False
tactic: have := h.1.eq ha hb (Classical.not_not.2 hab)
state_before: case refine_2
α : Type u_1
inst✝¹ : SemilatticeInf α
inst✝ : OrderBot α
s t : Set α
a✝ b✝ c : α
h : (s.Pairwise fun a b => ¬Disjoint a b) ∧ s ≠ {⊥}
a : α
ha : a ∈ s
b : α
hb : b ∈ s
hab : Disjoint a b
this : a = b
⊢ False
state_after: case refine_2
α : Type u_1
inst✝¹ : SemilatticeInf α
inst✝ : OrderBot α
s t : Set α
a✝ b✝ c : α
h : (s.Pairwise fun a b => ¬Disjoint a b) ∧ s ≠ {⊥}
a : α
ha : a ∈ s
b : α
hb : b ∈ s
hab : b = ⊥
this : a = b
⊢ False
tactic: rw [this, disjoint_self] at hab
state_before: case refine_2
α : Type u_1
inst✝¹ : SemilatticeInf α
inst✝ : OrderBot α
s t : Set α
a✝ b✝ c : α
h : (s.Pairwise fun a b => ¬Disjoint a b) ∧ s ≠ {⊥}
a : α
ha : a ∈ s
b : α
hb : b ∈ s
hab : b = ⊥
this : a = b
⊢ False
state_after: case refine_2
α : Type u_1
inst✝¹ : SemilatticeInf α
inst✝ : OrderBot α
s t : Set α
a✝ b✝ c : α
h : (s.Pairwise fun a b => ¬Disjoint a b) ∧ s ≠ {⊥}
a : α
ha : a ∈ s
b : α
hb : ⊥ ∈ s
hab : b = ⊥
this : a = b
⊢ False
tactic: rw [hab] at hb
state_before: case refine_2
α : Type u_1
inst✝¹ : SemilatticeInf α
inst✝ : OrderBot α
s t : Set α
a✝ b✝ c : α
h : (s.Pairwise fun a b => ¬Disjoint a b) ∧ s ≠ {⊥}
a : α
ha : a ∈ s
b : α
hb : ⊥ ∈ s
hab : b = ⊥
this : a = b
⊢ False
state_after: no goals
tactic: exact
    h.2
      (eq_singleton_iff_unique_mem.2
        ⟨hb, fun c hc => not_ne_iff.1 fun H => h.1 hb hc H.symm disjoint_bot_left⟩)
Theorem: csInf_div
File: Mathlib/Algebra/Order/Pointwise.lean

Proof steps:
state_before: α : Type u_1
inst✝³ : ConditionallyCompleteLattice α
inst✝² : Group α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
s t : Set α
hs₀ : s.Nonempty
hs₁ : BddBelow s
ht₀ : t.Nonempty
ht₁ : BddAbove t
⊢ sInf (s / t) = sInf s / sSup t
state_after: no goals
tactic: rw [div_eq_mul_inv, csInf_mul hs₀ hs₁ ht₀.inv ht₁.inv, csInf_inv ht₀ ht₁, div_eq_mul_inv]
Theorem: MeasureTheory.eLpNormEssSup_const
File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
c : F
hμ : μ ≠ 0
⊢ eLpNormEssSup (fun x => c) μ = ↑‖c‖₊
state_after: no goals
tactic: rw [eLpNormEssSup, essSup_const _ hμ]
Theorem: Bornology.IsBounded.exists_pos_norm_le
File: Mathlib/Analysis/Normed/Group/Bounded.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
hs : IsBounded s
R₀ : ℝ
hR₀ : ∀ x ∈ s, ‖x‖ ≤ R₀
⊢ max R₀ 1 > 0
state_after: no goals
tactic: positivity
Theorem: Num.mod_zero
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: n : Num
⊢ n.mod 0 = n
state_after: case zero

⊢ zero.mod 0 = zero

case pos
a✝ : PosNum
⊢ (pos a✝).mod 0 = pos a✝
tactic: cases n
Theorem: EReal.preimage_coe_Iio
File: Mathlib/Data/Real/EReal.lean

Proof steps:
state_before: y : ℝ
⊢ Real.toEReal ⁻¹' Iio ↑y = Iio y
state_after: y : ℝ
⊢ WithBot.some ∘ WithTop.some ⁻¹' Iio ↑↑y = Iio y
tactic: change (WithBot.some ∘ WithTop.some) ⁻¹' (Iio (WithBot.some (WithTop.some y))) = _
state_before: y : ℝ
⊢ WithBot.some ∘ WithTop.some ⁻¹' Iio ↑↑y = Iio y
state_after: y : ℝ
⊢ WithTop.some ⁻¹' (WithBot.some ⁻¹' Iio ↑↑y) = Iio y
tactic: refine preimage_comp.trans ?_
state_before: y : ℝ
⊢ WithTop.some ⁻¹' (WithBot.some ⁻¹' Iio ↑↑y) = Iio y
state_after: no goals
tactic: simp only [WithBot.preimage_coe_Iio, WithTop.preimage_coe_Iio]
Theorem: List.keys_kreplace
File: Mathlib/Data/List/Sigma.lean

Proof steps:
state_before: α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
b : β a
⊢ ∀ (a_1 b_1 : Sigma β), (b_1 ∈ if a = a_1.fst then some ⟨a, b⟩ else none) → a_1.fst = b_1.fst
state_after: case mk.mk
α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
b : β a
a₁ : α
b₂✝ : β a₁
a₂ : α
b₂ : β a₂
⊢ (⟨a₂, b₂⟩ ∈ if a = ⟨a₁, b₂✝⟩.fst then some ⟨a, b⟩ else none) → ⟨a₁, b₂✝⟩.fst = ⟨a₂, b₂⟩.fst
tactic: rintro ⟨a₁, b₂⟩ ⟨a₂, b₂⟩
state_before: case mk.mk
α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
b : β a
a₁ : α
b₂✝ : β a₁
a₂ : α
b₂ : β a₂
⊢ (⟨a₂, b₂⟩ ∈ if a = ⟨a₁, b₂✝⟩.fst then some ⟨a, b⟩ else none) → ⟨a₁, b₂✝⟩.fst = ⟨a₂, b₂⟩.fst
state_after: case mk.mk
α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
b : β a
a₁ : α
b₂✝ : β a₁
a₂ : α
b₂ : β a₂
⊢ (⟨a₂, b₂⟩ ∈ if a = a₁ then some ⟨a, b⟩ else none) → a₁ = a₂
tactic: dsimp
state_before: case mk.mk
α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
b : β a
a₁ : α
b₂✝ : β a₁
a₂ : α
b₂ : β a₂
⊢ (⟨a₂, b₂⟩ ∈ if a = a₁ then some ⟨a, b⟩ else none) → a₁ = a₂
state_after: no goals
tactic: split_ifs with h <;> simp (config := { contextual := true }) [h]
Theorem: RatFunc.isCoprime_num_denom
File: Mathlib/FieldTheory/RatFunc/Basic.lean

Proof steps:
state_before: K : Type u
inst✝ : Field K
x : RatFunc K
⊢ IsCoprime x.num x.denom
state_after: case f
K : Type u
inst✝ : Field K
p q : K[X]
hq : q ≠ 0
⊢ IsCoprime ((algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q).num
    ((algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q).denom
tactic: induction' x using RatFunc.induction_on with p q hq
state_before: case f
K : Type u
inst✝ : Field K
p q : K[X]
hq : q ≠ 0
⊢ IsCoprime ((algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q).num
    ((algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q).denom
state_after: case f
K : Type u
inst✝ : Field K
p q : K[X]
hq : q ≠ 0
⊢ IsCoprime (C (q / gcd p q).leadingCoeff⁻¹ * (p / gcd p q)) (C (q / gcd p q).leadingCoeff⁻¹ * (q / gcd p q))
tactic: rw [num_div, denom_div _ hq]
state_before: case f
K : Type u
inst✝ : Field K
p q : K[X]
hq : q ≠ 0
⊢ IsCoprime (C (q / gcd p q).leadingCoeff⁻¹ * (p / gcd p q)) (C (q / gcd p q).leadingCoeff⁻¹ * (q / gcd p q))
state_after: no goals
tactic: exact (isCoprime_mul_unit_left
    ((leadingCoeff_ne_zero.2 <| right_div_gcd_ne_zero hq).isUnit.inv.map C) _ _).2
      (isCoprime_div_gcd_div_gcd hq)
Theorem: Real.not_summable_one_div_natCast
File: Mathlib/Analysis/PSeries.lean

Proof steps:
state_before: ⊢ ¬Summable fun n => 1 / ↑n
state_after: no goals
tactic: simpa only [inv_eq_one_div] using not_summable_natCast_inv
Theorem: Submodule.mem_div_iff_smul_subset
File: Mathlib/Algebra/Algebra/Operations.lean

Proof steps:
state_before: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
M N : Submodule R A
m n x : A
I J : Submodule R A
h : x ∈ I / J
y : A
x✝ : y ∈ x • ↑J
y' : A
hy' : y' ∈ ↑J
xy'_eq_y : (fun x_1 => x • x_1) y' = y
⊢ y ∈ ↑I
state_after: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
M N : Submodule R A
m n x : A
I J : Submodule R A
h : x ∈ I / J
y : A
x✝ : y ∈ x • ↑J
y' : A
hy' : y' ∈ ↑J
xy'_eq_y : (fun x_1 => x • x_1) y' = y
⊢ (fun x_1 => x • x_1) y' ∈ ↑I
tactic: rw [← xy'_eq_y]
state_before: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
M N : Submodule R A
m n x : A
I J : Submodule R A
h : x ∈ I / J
y : A
x✝ : y ∈ x • ↑J
y' : A
hy' : y' ∈ ↑J
xy'_eq_y : (fun x_1 => x • x_1) y' = y
⊢ (fun x_1 => x • x_1) y' ∈ ↑I
state_after: case a
ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
M N : Submodule R A
m n x : A
I J : Submodule R A
h : x ∈ I / J
y : A
x✝ : y ∈ x • ↑J
y' : A
hy' : y' ∈ ↑J
xy'_eq_y : (fun x_1 => x • x_1) y' = y
⊢ y' ∈ J
tactic: apply h
state_before: case a
ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
M N : Submodule R A
m n x : A
I J : Submodule R A
h : x ∈ I / J
y : A
x✝ : y ∈ x • ↑J
y' : A
hy' : y' ∈ ↑J
xy'_eq_y : (fun x_1 => x • x_1) y' = y
⊢ y' ∈ J
state_after: no goals
tactic: assumption
Theorem: Finset.length_toList
File: Mathlib/Data/Finset/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
R : Type u_3
s✝ t u : Finset α
f : α → β
n : ℕ
s : Finset α
⊢ s.toList.length = s.card
state_after: no goals
tactic: rw [toList, ← Multiset.coe_card, Multiset.coe_toList, card_def]