ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Computation.results_bind
File: Mathlib/Data/Seq/Computation.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
s : Computation α
f : α → Computation β
a : α
b : β
m n : ℕ
h1 : s.Results a m
h2 : (f a).Results b n
⊢ (s.bind f).Results b (n + m)
state_after: α : Type u
β : Type v
γ : Type w
s : Computation α
f : α → Computation β
a : α
b : β
m n : ℕ
h1 : s.Results a m
h2 : (f a).Results b n
this : a ∈ s
⊢ (s.bind f).Results b (n + m)
tactic: have := h1.mem
state_before: α : Type u
β : Type v
γ : Type w
s : Computation α
f : α → Computation β
a : α
b : β
m n : ℕ
h1 : s.Results a m
h2 : (f a).Results b n
this : a ∈ s
⊢ (s.bind f).Results b (n + m)
state_after: α : Type u
β : Type v
γ : Type w
s : Computation α
f : α → Computation β
a : α
b : β
n : ℕ
h2 : (f a).Results b n
this : a ∈ s
⊢ ∀ {m : ℕ}, s.Results a m → (s.bind f).Results b (n + m)
tactic: revert m
state_before: α : Type u
β : Type v
γ : Type w
s : Computation α
f : α → Computation β
a : α
b : β
n : ℕ
h2 : (f a).Results b n
this : a ∈ s
⊢ ∀ {m : ℕ}, s.Results a m → (s.bind f).Results b (n + m)
state_after: α : Type u
β : Type v
γ : Type w
s : Computation α
f : α → Computation β
a : α
b : β
n : ℕ
h2 : (f a).Results b n
this : a ∈ s
⊢ ∀ {m : ℕ}, (pure a).Results a m → ((pure a).bind f).Results b (n + m)

α : Type u
β : Type v
γ : Type w
s : Computation α
f : α → Computation β
a : α
b : β
n : ℕ
h2 : (f a).Results b n
this : a ∈ s
⊢ ∀ (s : Computation α),
    (∀ {m : ℕ}, s.Results a m → (s.bind f).Results b (n + m)) →
      ∀ {m : ℕ}, s.think.Results a m → (s.think.bind f).Results b (n + m)
tactic: apply memRecOn this _ fun s IH => _
Theorem: disjoint_sdiff_iff_le
File: Mathlib/Order/BooleanAlgebra.lean

Proof steps:
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
hz : z ≤ y
hx : x ≤ y
H : Disjoint z (y \ x)
⊢ z ⊔ y \ x ≤ x ⊔ y \ x
state_after: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
hz : z ≤ y
hx : x ≤ y
H : Disjoint z (y \ x)
⊢ z ⊔ y \ x ≤ y
tactic: rw [sup_sdiff_cancel_right hx]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
hz : z ≤ y
hx : x ≤ y
H : Disjoint z (y \ x)
⊢ z ⊔ y \ x ≤ y
state_after: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
hz : z ≤ y
hx : x ≤ y
H : Disjoint z (y \ x)
⊢ z ⊔ y ≤ y
tactic: refine le_trans (sup_le_sup_left sdiff_le z) ?_
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
hz : z ≤ y
hx : x ≤ y
H : Disjoint z (y \ x)
⊢ z ⊔ y ≤ y
state_after: no goals
tactic: rw [sup_eq_right.2 hz]
Theorem: HomologicalComplex.unopEquivalence_inverse
File: Mathlib/Algebra/Homology/Opposite.lean

Proof steps:
state_before: ι : Type u_1
V : Type u_2
inst✝¹ : Category.{?u.66755, u_2} V
c : ComplexShape ι
inst✝ : HasZeroMorphisms V
X : (HomologicalComplex Vᵒᵖ c)ᵒᵖ
⊢ (unopFunctor V c).map ((unopUnitIso V c).hom.app X) ≫ (unopCounitIso V c).hom.app ((unopFunctor V c).obj X) =
    𝟙 ((unopFunctor V c).obj X)
state_after: case h
ι : Type u_1
V : Type u_2
inst✝¹ : Category.{?u.66755, u_2} V
c : ComplexShape ι
inst✝ : HasZeroMorphisms V
X : (HomologicalComplex Vᵒᵖ c)ᵒᵖ
i✝ : ι
⊢ ((unopFunctor V c).map ((unopUnitIso V c).hom.app X) ≫ (unopCounitIso V c).hom.app ((unopFunctor V c).obj X)).f i✝ =
    (𝟙 ((unopFunctor V c).obj X)).f i✝
tactic: ext
state_before: case h
ι : Type u_1
V : Type u_2
inst✝¹ : Category.{?u.66755, u_2} V
c : ComplexShape ι
inst✝ : HasZeroMorphisms V
X : (HomologicalComplex Vᵒᵖ c)ᵒᵖ
i✝ : ι
⊢ ((unopFunctor V c).map ((unopUnitIso V c).hom.app X) ≫ (unopCounitIso V c).hom.app ((unopFunctor V c).obj X)).f i✝ =
    (𝟙 ((unopFunctor V c).obj X)).f i✝
state_after: case h
ι : Type u_1
V : Type u_2
inst✝¹ : Category.{?u.66755, u_2} V
c : ComplexShape ι
inst✝ : HasZeroMorphisms V
X : (HomologicalComplex Vᵒᵖ c)ᵒᵖ
i✝ : ι
⊢ ((unopFunctor V c).map ((unopUnitIso V c).hom.app X)).f i✝ ≫
      ((unopCounitIso V c).hom.app ((unopFunctor V c).obj X)).f i✝ =
    (𝟙 ((unopFunctor V c).obj X)).f i✝
tactic: simp only [opUnitIso, opCounitIso, NatIso.ofComponents_hom_app, Iso.op_hom, comp_f,
      opFunctor_map_f, Quiver.Hom.unop_op, Hom.isoOfComponents_hom_f]
state_before: case h
ι : Type u_1
V : Type u_2
inst✝¹ : Category.{?u.66755, u_2} V
c : ComplexShape ι
inst✝ : HasZeroMorphisms V
X : (HomologicalComplex Vᵒᵖ c)ᵒᵖ
i✝ : ι
⊢ ((unopFunctor V c).map ((unopUnitIso V c).hom.app X)).f i✝ ≫
      ((unopCounitIso V c).hom.app ((unopFunctor V c).obj X)).f i✝ =
    (𝟙 ((unopFunctor V c).obj X)).f i✝
state_after: no goals
tactic: exact Category.comp_id _
Theorem: PiTensorProduct.piTensorHomMap_tprod_tprod
File: Mathlib/LinearAlgebra/PiTensorProduct.lean

Proof steps:
state_before: ι : Type u_1
ι₂ : Type u_2
ι₃ : Type u_3
R : Type u_4
inst✝¹¹ : CommSemiring R
R₁ : Type u_5
R₂ : Type u_6
s : ι → Type u_7
inst✝¹⁰ : (i : ι) → AddCommMonoid (s i)
inst✝⁹ : (i : ι) → Module R (s i)
M : Type u_8
inst✝⁸ : AddCommMonoid M
inst✝⁷ : Module R M
E : Type u_9
inst✝⁶ : AddCommMonoid E
inst✝⁵ : Module R E
F : Type u_10
inst✝⁴ : AddCommMonoid F
t : ι → Type u_11
t' : ι → Type u_12
inst✝³ : (i : ι) → AddCommMonoid (t i)
inst✝² : (i : ι) → Module R (t i)
inst✝¹ : (i : ι) → AddCommMonoid (t' i)
inst✝ : (i : ι) → Module R (t' i)
g : (i : ι) → t i →ₗ[R] t' i
f✝ f : (i : ι) → s i →ₗ[R] t i
x : (i : ι) → s i
⊢ (piTensorHomMap ((tprod R) f)) ((tprod R) x) = ⨂ₜ[R] (i : ι), (f i) (x i)
state_after: no goals
tactic: simp [piTensorHomMap]
Theorem: ZNum.gcd_to_nat
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: a b : ZNum
⊢ (↑a.abs).gcd ↑b.abs = (↑a).gcd ↑b
state_after: a b : ZNum
⊢ (↑a).natAbs.gcd (↑b).natAbs = (↑a).gcd ↑b
tactic: simp only [abs_to_nat]
state_before: a b : ZNum
⊢ (↑a).natAbs.gcd (↑b).natAbs = (↑a).gcd ↑b
state_after: no goals
tactic: rfl
Theorem: Real.log_nonneg_iff
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

Proof steps:
state_before: x y : ℝ
hx : 0 < x
⊢ 0 ≤ log x ↔ 1 ≤ x
state_after: no goals
tactic: rw [← not_lt, log_neg_iff hx, not_lt]
Theorem: Computability.Encoding.encode_injective
File: Mathlib/Computability/Encoding.lean

Proof steps:
state_before: α : Type u
e : Encoding α
⊢ Function.Injective e.encode
state_after: α : Type u
e : Encoding α
x✝¹ x✝ : α
h : e.encode x✝¹ = e.encode x✝
⊢ some x✝¹ = some x✝
tactic: refine fun _ _ h => Option.some_injective _ ?_
state_before: α : Type u
e : Encoding α
x✝¹ x✝ : α
h : e.encode x✝¹ = e.encode x✝
⊢ some x✝¹ = some x✝
state_after: no goals
tactic: rw [← e.decode_encode, ← e.decode_encode, h]
Theorem: orthogonalProjection_mem_subspace_eq_self
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : _root_.RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : HasOrthogonalProjection K
v : ↥K
⊢ (orthogonalProjection K) ↑v = v
state_after: case a
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : _root_.RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : HasOrthogonalProjection K
v : ↥K
⊢ ↑((orthogonalProjection K) ↑v) = ↑v
tactic: ext
state_before: case a
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : _root_.RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : HasOrthogonalProjection K
v : ↥K
⊢ ↑((orthogonalProjection K) ↑v) = ↑v
state_after: no goals
tactic: apply eq_orthogonalProjection_of_mem_of_inner_eq_zero <;> simp
Theorem: isCompact_range_of_mulSupport_subset_isCompact
File: Mathlib/Topology/Support.lean

Proof steps:
state_before: X : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
M : Type u_7
E : Type u_8
R : Type u_9
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace α'
inst✝³ : One β
inst✝² : One γ
inst✝¹ : One δ
g : β → γ
f : α → β
f₂ : α → γ
m : β → γ → δ
x : α
inst✝ : TopologicalSpace β
hf : Continuous f
k : Set α
hk : IsCompact k
h'f : mulSupport f ⊆ k
⊢ IsCompact (range f)
state_after: case inl
X : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
M : Type u_7
E : Type u_8
R : Type u_9
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace α'
inst✝³ : One β
inst✝² : One γ
inst✝¹ : One δ
g : β → γ
f : α → β
f₂ : α → γ
m : β → γ → δ
x : α
inst✝ : TopologicalSpace β
hf : Continuous f
k : Set α
hk : IsCompact k
h'f : mulSupport f ⊆ k
h2 : range f = f '' k
⊢ IsCompact (f '' k)

case inr
X : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
M : Type u_7
E : Type u_8
R : Type u_9
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace α'
inst✝³ : One β
inst✝² : One γ
inst✝¹ : One δ
g : β → γ
f : α → β
f₂ : α → γ
m : β → γ → δ
x : α
inst✝ : TopologicalSpace β
hf : Continuous f
k : Set α
hk : IsCompact k
h'f : mulSupport f ⊆ k
h2 : range f = insert 1 (f '' k)
⊢ IsCompact (insert 1 (f '' k))
tactic: cases' range_eq_image_or_of_mulSupport_subset h'f with h2 h2 <;> rw [h2]
state_before: case inl
X : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
M : Type u_7
E : Type u_8
R : Type u_9
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace α'
inst✝³ : One β
inst✝² : One γ
inst✝¹ : One δ
g : β → γ
f : α → β
f₂ : α → γ
m : β → γ → δ
x : α
inst✝ : TopologicalSpace β
hf : Continuous f
k : Set α
hk : IsCompact k
h'f : mulSupport f ⊆ k
h2 : range f = f '' k
⊢ IsCompact (f '' k)

case inr
X : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
M : Type u_7
E : Type u_8
R : Type u_9
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace α'
inst✝³ : One β
inst✝² : One γ
inst✝¹ : One δ
g : β → γ
f : α → β
f₂ : α → γ
m : β → γ → δ
x : α
inst✝ : TopologicalSpace β
hf : Continuous f
k : Set α
hk : IsCompact k
h'f : mulSupport f ⊆ k
h2 : range f = insert 1 (f '' k)
⊢ IsCompact (insert 1 (f '' k))
state_after: no goals
tactic: exacts [hk.image hf, (hk.image hf).insert 1]
Theorem: Composition.eq_ones_iff_length
File: Mathlib/Combinatorics/Enumerative/Composition.lean

Proof steps:
state_before: n : ℕ
c✝ c : Composition n
⊢ c = ones n ↔ c.length = n
state_after: case mp
n : ℕ
c✝ c : Composition n
⊢ c = ones n → c.length = n

case mpr
n : ℕ
c✝ c : Composition n
⊢ c.length = n → c = ones n
tactic: constructor
Theorem: Equiv.subtypeEquiv_symm
File: Mathlib/Logic/Equiv/Basic.lean

Proof steps:
state_before: α : Sort ?u.56697
β : Sort ?u.56701
p : α → Prop
q : β → Prop
e : α ≃ β
h : ∀ (a : α), p a ↔ q (e a)
a : β
⊢ q a ↔ p (e.symm a)
state_after: case h.e'_1.h.e'_1
α : Sort ?u.56697
β : Sort ?u.56701
p : α → Prop
q : β → Prop
e : α ≃ β
h : ∀ (a : α), p a ↔ q (e a)
a : β
⊢ a = e (e.symm a)
tactic: convert (h <| e.symm a).symm
state_before: case h.e'_1.h.e'_1
α : Sort ?u.56697
β : Sort ?u.56701
p : α → Prop
q : β → Prop
e : α ≃ β
h : ∀ (a : α), p a ↔ q (e a)
a : β
⊢ a = e (e.symm a)
state_after: no goals
tactic: exact (e.apply_symm_apply a).symm
Theorem: ne₁₃_of_not_collinear
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ p₃ : P
h : ¬Collinear k {p₁, p₂, p₃}
⊢ p₁ ≠ p₃
state_after: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ : P
h : ¬Collinear k {p₁, p₂, p₁}
⊢ False
tactic: rintro rfl
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ : P
h : ¬Collinear k {p₁, p₂, p₁}
⊢ False
state_after: no goals
tactic: simp [collinear_pair] at h
Theorem: NonUnitalStarAlgHom.continuous_realContinuousMapZeroOfNNReal
File: Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unique.lean

Proof steps:
state_before: X : Type u_1
inst✝⁸ : TopologicalSpace X
inst✝⁷ : Zero X
A : Type u_2
inst✝⁶ : TopologicalSpace A
inst✝⁵ : NonUnitalRing A
inst✝⁴ : StarRing A
inst✝³ : Module ℝ A
inst✝² : IsScalarTower ℝ A A
inst✝¹ : SMulCommClass ℝ A A
inst✝ : TopologicalRing A
φ : C(X, ℝ≥0)₀ →⋆ₙₐ[ℝ≥0] A
hφ : Continuous ⇑φ
⊢ Continuous ⇑φ.realContinuousMapZeroOfNNReal
state_after: X : Type u_1
inst✝⁸ : TopologicalSpace X
inst✝⁷ : Zero X
A : Type u_2
inst✝⁶ : TopologicalSpace A
inst✝⁵ : NonUnitalRing A
inst✝⁴ : StarRing A
inst✝³ : Module ℝ A
inst✝² : IsScalarTower ℝ A A
inst✝¹ : SMulCommClass ℝ A A
inst✝ : TopologicalRing A
φ : C(X, ℝ≥0)₀ →⋆ₙₐ[ℝ≥0] A
hφ : Continuous ⇑φ
⊢ Continuous fun f => φ f.toNNReal - φ (-f).toNNReal
tactic: simp [realContinuousMapZeroOfNNReal]
state_before: X : Type u_1
inst✝⁸ : TopologicalSpace X
inst✝⁷ : Zero X
A : Type u_2
inst✝⁶ : TopologicalSpace A
inst✝⁵ : NonUnitalRing A
inst✝⁴ : StarRing A
inst✝³ : Module ℝ A
inst✝² : IsScalarTower ℝ A A
inst✝¹ : SMulCommClass ℝ A A
inst✝ : TopologicalRing A
φ : C(X, ℝ≥0)₀ →⋆ₙₐ[ℝ≥0] A
hφ : Continuous ⇑φ
⊢ Continuous fun f => φ f.toNNReal - φ (-f).toNNReal
state_after: no goals
tactic: fun_prop
Theorem: Prod.mk_lt_mk_of_lt_of_le
File: Mathlib/Order/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝¹ : Preorder α
inst✝ : Preorder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
h₁ : a₁ < a₂
h₂ : b₁ ≤ b₂
⊢ (a₁, b₁) < (a₂, b₂)
state_after: no goals
tactic: simp [lt_iff, *]
Theorem: Finset.disjoint_singleton
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : α → β
s t u : Finset α
a b : α
⊢ _root_.Disjoint {a} {b} ↔ a ≠ b
state_after: no goals
tactic: rw [disjoint_singleton_left, mem_singleton]
Theorem: Linarith.le_of_le_of_eq
File: Mathlib/Tactic/Linarith/Lemmas.lean

Proof steps:
state_before: α : Type u_1
inst✝ : OrderedSemiring α
a b : α
ha : a ≤ 0
hb : b = 0
⊢ a + b ≤ 0
state_after: no goals
tactic: simp [*]
Theorem: Substring.Valid.data_dropWhile
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

Proof steps:
state_before: p : Char → Bool
x✝ : Substring
h✝ : x✝.Valid
w✝² w✝¹ w✝ : List Char
h : ValidFor w✝² w✝¹ w✝ x✝
⊢ (x✝.dropWhile p).toString.data = List.dropWhile p x✝.toString.data
state_after: no goals
tactic: simp [(h.dropWhile _).toString, h.toString]
Theorem: AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.pullbackConeOfLeftLift_snd
File: Mathlib/Geometry/RingedSpace/OpenImmersion.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y Z : PresheafedSpace C
f : X ⟶ Z
hf : IsOpenImmersion f
g : Y ⟶ Z
s : PullbackCone f g
⊢ pullbackConeOfLeftLift f g s ≫ (pullbackConeOfLeft f g).snd = s.snd
state_after: case refine_1
C : Type u
inst✝ : Category.{v, u} C
X Y Z : PresheafedSpace C
f : X ⟶ Z
hf : IsOpenImmersion f
g : Y ⟶ Z
s : PullbackCone f g
⊢ (pullbackConeOfLeftLift f g s ≫ (pullbackConeOfLeft f g).snd).base = s.snd.base

case refine_2
C : Type u
inst✝ : Category.{v, u} C
X Y Z : PresheafedSpace C
f : X ⟶ Z
hf : IsOpenImmersion f
g : Y ⟶ Z
s : PullbackCone f g
x : (Opens ↑↑Y)ᵒᵖ
⊢ ((pullbackConeOfLeftLift f g s ≫ (pullbackConeOfLeft f g).snd).c ≫ whiskerRight (eqToHom ⋯) s.pt.presheaf).app x =
    s.snd.c.app x
tactic: refine PresheafedSpace.Hom.ext _ _ ?_ <| NatTrans.ext _ _ <| funext fun x => ?_
Theorem: Associates.mk_quot_out
File: Mathlib/Algebra/Associated/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : Monoid α
a : α
⊢ Quot.out (Associates.mk a) ~ᵤ a
state_after: no goals
tactic: rw [← Associates.mk_eq_mk_iff_associated, Associates.quot_out]
Theorem: CovBy.Ioc_eq
File: Mathlib/Order/Cover.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : PartialOrder α
a b c : α
h : a ⋖ b
⊢ Ioc a b = {b}
state_after: no goals
tactic: rw [← Ioo_union_right h.lt, h.Ioo_eq, empty_union]
Theorem: one_div_le_one_div_of_neg_of_le
File: Mathlib/Algebra/Order/Field/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
hb : b < 0
h : a ≤ b
⊢ 1 / b ≤ 1 / a
state_after: no goals
tactic: rwa [div_le_iff_of_neg' hb, ← div_eq_mul_one_div, div_le_one_of_neg (h.trans_lt hb)]
Theorem: IsLocalization.to_map_eq_zero_iff
File: Mathlib/RingTheory/Localization/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommRing R
M : Submonoid R
S : Type u_2
inst✝³ : CommRing S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommRing P
K : Type u_4
inst✝ : IsLocalization M S
x : R
hM : M ≤ nonZeroDivisors R
⊢ (algebraMap R S) x = 0 ↔ x = 0
state_after: R : Type u_1
inst✝⁴ : CommRing R
M : Submonoid R
S : Type u_2
inst✝³ : CommRing S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommRing P
K : Type u_4
inst✝ : IsLocalization M S
x : R
hM : M ≤ nonZeroDivisors R
⊢ (algebraMap R S) x = (algebraMap R S) 0 ↔ x = 0
tactic: rw [← (algebraMap R S).map_zero]
state_before: R : Type u_1
inst✝⁴ : CommRing R
M : Submonoid R
S : Type u_2
inst✝³ : CommRing S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommRing P
K : Type u_4
inst✝ : IsLocalization M S
x : R
hM : M ≤ nonZeroDivisors R
⊢ (algebraMap R S) x = (algebraMap R S) 0 ↔ x = 0
state_after: case mp
R : Type u_1
inst✝⁴ : CommRing R
M : Submonoid R
S : Type u_2
inst✝³ : CommRing S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommRing P
K : Type u_4
inst✝ : IsLocalization M S
x : R
hM : M ≤ nonZeroDivisors R
h : (algebraMap R S) x = (algebraMap R S) 0
⊢ x = 0

case mpr
R : Type u_1
inst✝⁴ : CommRing R
M : Submonoid R
S : Type u_2
inst✝³ : CommRing S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommRing P
K : Type u_4
inst✝ : IsLocalization M S
x : R
hM : M ≤ nonZeroDivisors R
h : x = 0
⊢ (algebraMap R S) x = (algebraMap R S) 0
tactic: constructor <;> intro h
Theorem: MeasureTheory.condexpIndL1_of_measure_eq_top
File: Mathlib/MeasureTheory/Function/ConditionalExpectation/CondexpL1.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
G' : Type u_6
𝕜 : Type u_7
p : ℝ≥0∞
inst✝¹² : RCLike 𝕜
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
inst✝⁹ : NormedAddCommGroup F'
inst✝⁸ : NormedSpace 𝕜 F'
inst✝⁷ : NormedSpace ℝ F'
inst✝⁶ : CompleteSpace F'
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : NormedAddCommGroup G'
inst✝³ : NormedSpace ℝ G'
inst✝² : CompleteSpace G'
m m0 : MeasurableSpace α
μ : Measure α
s t : Set α
inst✝¹ : NormedSpace ℝ G
hm : m ≤ m0
inst✝ : SigmaFinite (μ.trim hm)
hμs : μ s = ⊤
x : G
⊢ condexpIndL1 hm μ s x = 0
state_after: no goals
tactic: simp only [condexpIndL1, hμs, eq_self_iff_true, not_true, Ne, dif_neg, not_false_iff,
    and_false_iff]
Theorem: Set.image_restrict
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
f : α → β
s t : Set α
⊢ s.restrict f '' (Subtype.val ⁻¹' t) = f '' (t ∩ s)
state_after: no goals
tactic: rw [restrict_eq, image_comp, image_preimage_eq_inter_range, Subtype.range_coe]
Theorem: IsUnit.div_mul_right
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
M : Type u_1
N : Type u_2
inst✝ : DivisionCommMonoid α
a b✝ c d : α
h : IsUnit a
b : α
⊢ a / (a * b) = 1 / b
state_after: no goals
tactic: rw [mul_comm, h.div_mul_left]
Theorem: minpoly.dvd
File: Mathlib/FieldTheory/Minpoly/Field.lean

Proof steps:
state_before: A : Type u_1
B : Type u_2
inst✝² : Field A
inst✝¹ : Ring B
inst✝ : Algebra A B
x : B
p : A[X]
hp : (Polynomial.aeval x) p = 0
⊢ minpoly A x ∣ p
state_after: case pos
A : Type u_1
B : Type u_2
inst✝² : Field A
inst✝¹ : Ring B
inst✝ : Algebra A B
x : B
p : A[X]
hp : (Polynomial.aeval x) p = 0
hp0 : p = 0
⊢ minpoly A x ∣ p

case neg
A : Type u_1
B : Type u_2
inst✝² : Field A
inst✝¹ : Ring B
inst✝ : Algebra A B
x : B
p : A[X]
hp : (Polynomial.aeval x) p = 0
hp0 : ¬p = 0
⊢ minpoly A x ∣ p
tactic: by_cases hp0 : p = 0
state_before: case neg
A : Type u_1
B : Type u_2
inst✝² : Field A
inst✝¹ : Ring B
inst✝ : Algebra A B
x : B
p : A[X]
hp : (Polynomial.aeval x) p = 0
hp0 : ¬p = 0
⊢ minpoly A x ∣ p
state_after: case neg
A : Type u_1
B : Type u_2
inst✝² : Field A
inst✝¹ : Ring B
inst✝ : Algebra A B
x : B
p : A[X]
hp : (Polynomial.aeval x) p = 0
hp0 : ¬p = 0
hx : IsIntegral A x
⊢ minpoly A x ∣ p
tactic: have hx : IsIntegral A x := IsAlgebraic.isIntegral ⟨p, hp0, hp⟩
state_before: case neg
A : Type u_1
B : Type u_2
inst✝² : Field A
inst✝¹ : Ring B
inst✝ : Algebra A B
x : B
p : A[X]
hp : (Polynomial.aeval x) p = 0
hp0 : ¬p = 0
hx : IsIntegral A x
⊢ minpoly A x ∣ p
state_after: case neg
A : Type u_1
B : Type u_2
inst✝² : Field A
inst✝¹ : Ring B
inst✝ : Algebra A B
x : B
p : A[X]
hp : (Polynomial.aeval x) p = 0
hp0 : ¬p = 0
hx : IsIntegral A x
⊢ p %ₘ minpoly A x = 0
tactic: rw [← modByMonic_eq_zero_iff_dvd (monic hx)]
state_before: case neg
A : Type u_1
B : Type u_2
inst✝² : Field A
inst✝¹ : Ring B
inst✝ : Algebra A B
x : B
p : A[X]
hp : (Polynomial.aeval x) p = 0
hp0 : ¬p = 0
hx : IsIntegral A x
⊢ p %ₘ minpoly A x = 0
state_after: case neg
A : Type u_1
B : Type u_2
inst✝² : Field A
inst✝¹ : Ring B
inst✝ : Algebra A B
x : B
p : A[X]
hp : (Polynomial.aeval x) p = 0
hp0 : ¬p = 0
hx : IsIntegral A x
hnz : ¬p %ₘ minpoly A x = 0
⊢ False
tactic: by_contra hnz
state_before: case neg
A : Type u_1
B : Type u_2
inst✝² : Field A
inst✝¹ : Ring B
inst✝ : Algebra A B
x : B
p : A[X]
hp : (Polynomial.aeval x) p = 0
hp0 : ¬p = 0
hx : IsIntegral A x
hnz : ¬p %ₘ minpoly A x = 0
⊢ False
state_after: case neg
A : Type u_1
B : Type u_2
inst✝² : Field A
inst✝¹ : Ring B
inst✝ : Algebra A B
x : B
p : A[X]
hp : (Polynomial.aeval x) p = 0
hp0 : ¬p = 0
hx : IsIntegral A x
hnz : ¬p %ₘ minpoly A x = 0
⊢ (p %ₘ minpoly A x).degree < (minpoly A x).degree
tactic: apply degree_le_of_ne_zero A x hnz
    ((aeval_modByMonic_eq_self_of_root (monic hx) (aeval _ _)).trans hp) |>.not_lt
state_before: case neg
A : Type u_1
B : Type u_2
inst✝² : Field A
inst✝¹ : Ring B
inst✝ : Algebra A B
x : B
p : A[X]
hp : (Polynomial.aeval x) p = 0
hp0 : ¬p = 0
hx : IsIntegral A x
hnz : ¬p %ₘ minpoly A x = 0
⊢ (p %ₘ minpoly A x).degree < (minpoly A x).degree
state_after: no goals
tactic: exact degree_modByMonic_lt _ (monic hx)
Theorem: MeasureTheory.IsSetSemiring.pairwiseDisjoint_diffFinset
File: Mathlib/MeasureTheory/SetSemiring.lean

Proof steps:
state_before: α : Type u_1
C : Set (Set α)
s t : Set α
hC : IsSetSemiring C
hs : s ∈ C
ht : t ∈ C
⊢ (↑(hC.diffFinset hs ht)).PairwiseDisjoint id
state_after: no goals
tactic: classical
  simp only [diffFinset, coe_sdiff, coe_singleton]
  exact Set.PairwiseDisjoint.subset (hC.diff_eq_sUnion' s hs t ht).choose_spec.2.1
      diff_subset
Theorem: Monotone.of_map_inf
File: Mathlib/Order/Lattice.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝¹ : SemilatticeInf α
inst✝ : SemilatticeInf β
f : α → β
h : ∀ (x y : α), f (x ⊓ y) = f x ⊓ f y
x y : α
hxy : x ≤ y
⊢ f x ⊓ f y = f x
state_after: no goals
tactic: rw [← h, inf_eq_left.2 hxy]
Theorem: WeierstrassCurve.Jacobian.eval_polynomialX_of_Z_ne_zero
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → F
hPz : P z ≠ 0
⊢ (eval P) W.polynomialX / P z ^ 4 = Polynomial.evalEval (P x / P z ^ 2) (P y / P z ^ 3) W.toAffine.polynomialX
state_after: no goals
tactic: linear_combination (norm := (rw [eval_polynomialX, Affine.evalEval_polynomialX]; ring1))
    W.a₁ * P y / P z ^ 3 * div_self hPz - 2 * W.a₂ * P x / P z ^ 2 * div_self (pow_ne_zero 2 hPz)
      - W.a₄ * div_self (pow_ne_zero 4 hPz)
Theorem: zero_mem_preCantorSet
File: Mathlib/Topology/Instances/CantorSet.lean

Proof steps:
state_before: n : ℕ
⊢ 0 ∈ preCantorSet n
state_after: no goals
tactic: induction n with
  | zero =>
    simp [preCantorSet]
  | succ n ih =>
    exact Or.inl ⟨0, ih, by simp only [zero_div]⟩
Theorem: Complex.lim_re
File: Mathlib/Data/Complex/Abs.lean

Proof steps:
state_before: f : CauSeq ℂ ⇑abs'
⊢ (cauSeqRe f).lim = f.lim.re
state_after: f : CauSeq ℂ ⇑abs'
⊢ (cauSeqRe f).lim = (↑(cauSeqRe f).lim + ↑(cauSeqIm f).lim * I).re
tactic: rw [lim_eq_lim_im_add_lim_re]
state_before: f : CauSeq ℂ ⇑abs'
⊢ (cauSeqRe f).lim = (↑(cauSeqRe f).lim + ↑(cauSeqIm f).lim * I).re
state_after: no goals
tactic: simp [ofReal']