ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: InnerProductSpace.Core.inner_sub_sub_self
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝² : _root_.RCLike 𝕜
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
x y : F
⊢ ⟪x - y, x - y⟫_𝕜 = ⟪x, x⟫_𝕜 - ⟪x, y⟫_𝕜 - ⟪y, x⟫_𝕜 + ⟪y, y⟫_𝕜
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝² : _root_.RCLike 𝕜
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
x y : F
⊢ ⟪x, x⟫_𝕜 - ⟪y, x⟫_𝕜 - (⟪x, y⟫_𝕜 - ⟪y, y⟫_𝕜) = ⟪x, x⟫_𝕜 - ⟪x, y⟫_𝕜 - ⟪y, x⟫_𝕜 + ⟪y, y⟫_𝕜
tactic: simp only [inner_sub_left, inner_sub_right]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝² : _root_.RCLike 𝕜
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
x y : F
⊢ ⟪x, x⟫_𝕜 - ⟪y, x⟫_𝕜 - (⟪x, y⟫_𝕜 - ⟪y, y⟫_𝕜) = ⟪x, x⟫_𝕜 - ⟪x, y⟫_𝕜 - ⟪y, x⟫_𝕜 + ⟪y, y⟫_𝕜
state_after: no goals
tactic: ring
Theorem: zsmul_neg
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionMonoid α
a✝ b c d a : α
n : ℕ
⊢ a⁻¹ ^ ↑n = (a ^ ↑n)⁻¹
state_after: no goals
tactic: rw [zpow_natCast, zpow_natCast, inv_pow]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionMonoid α
a✝ b c d a : α
n : ℕ
⊢ a⁻¹ ^ Int.negSucc n = (a ^ Int.negSucc n)⁻¹
state_after: no goals
tactic: rw [zpow_negSucc, zpow_negSucc, inv_pow]
Theorem: LinearIndependent.insert
File: Mathlib/LinearAlgebra/LinearIndependent.lean

Proof steps:
state_before: ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v : ι → V
s t : Set V
x y z : V
hs : LinearIndependent K fun (b : ↑s) => ↑b
hx : x ∉ span K s
⊢ LinearIndependent K fun (b : ↑(insert x s)) => ↑b
state_after: ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v : ι → V
s t : Set V
x y z : V
hs : LinearIndependent K fun (b : ↑s) => ↑b
hx : x ∉ span K s
⊢ LinearIndependent K fun (b : ↑(s ∪ {x})) => ↑b
tactic: rw [← union_singleton]
state_before: ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v : ι → V
s t : Set V
x y z : V
hs : LinearIndependent K fun (b : ↑s) => ↑b
hx : x ∉ span K s
⊢ LinearIndependent K fun (b : ↑(s ∪ {x})) => ↑b
state_after: ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v : ι → V
s t : Set V
x y z : V
hs : LinearIndependent K fun (b : ↑s) => ↑b
hx : x ∉ span K s
x0 : x ≠ 0
⊢ LinearIndependent K fun (b : ↑(s ∪ {x})) => ↑b
tactic: have x0 : x ≠ 0 := mt (by rintro rfl; apply zero_mem (span K s)) hx
state_before: ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v : ι → V
s t : Set V
x y z : V
hs : LinearIndependent K fun (b : ↑s) => ↑b
hx : x ∉ span K s
x0 : x ≠ 0
⊢ LinearIndependent K fun (b : ↑(s ∪ {x})) => ↑b
state_after: ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v : ι → V
s t : Set V
x y z : V
hs : LinearIndependent K fun (b : ↑s) => ↑b
hx : x ∉ span K s
x0 : x ≠ 0
⊢ Disjoint (span K s) (span K {x})
tactic: apply hs.union (linearIndependent_singleton x0)
state_before: ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v : ι → V
s t : Set V
x y z : V
hs : LinearIndependent K fun (b : ↑s) => ↑b
hx : x ∉ span K s
x0 : x ≠ 0
⊢ Disjoint (span K s) (span K {x})
state_after: no goals
tactic: rwa [disjoint_span_singleton' x0]
Theorem: Matrix.circulant_single
File: Mathlib/LinearAlgebra/Matrix/Circulant.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : Type u_3
n✝ : Type u_4
R : Type u_5
n : Type u_6
inst✝³ : Semiring α
inst✝² : DecidableEq n
inst✝¹ : AddGroup n
inst✝ : Fintype n
a : α
⊢ circulant (Pi.single 0 a) = (scalar n) a
state_after: case a
α : Type u_1
β : Type u_2
m : Type u_3
n✝ : Type u_4
R : Type u_5
n : Type u_6
inst✝³ : Semiring α
inst✝² : DecidableEq n
inst✝¹ : AddGroup n
inst✝ : Fintype n
a : α
i j : n
⊢ circulant (Pi.single 0 a) i j = (scalar n) a i j
tactic: ext i j
state_before: case a
α : Type u_1
β : Type u_2
m : Type u_3
n✝ : Type u_4
R : Type u_5
n : Type u_6
inst✝³ : Semiring α
inst✝² : DecidableEq n
inst✝¹ : AddGroup n
inst✝ : Fintype n
a : α
i j : n
⊢ circulant (Pi.single 0 a) i j = (scalar n) a i j
state_after: no goals
tactic: simp [Pi.single_apply, diagonal_apply, sub_eq_zero]
Theorem: prod_eq_tprod_mulIndicator
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f✝ g : β → α
a a₁ a₂ : α
f : β → α
s : Finset β
⊢ ∏ x ∈ s, f x = ∏' (x : β), (↑s).mulIndicator f x
state_after: no goals
tactic: rw [tprod_eq_prod' (Set.mulSupport_mulIndicator_subset),
      Finset.prod_mulIndicator_subset _ Finset.Subset.rfl]
Theorem: disjoint_nhdsWithin_of_mem_discrete
File: Mathlib/Topology/Separation.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : FirstCountableTopology X
s : Set X
inst✝ : DiscreteTopology ↑s
x : X
hx : x ∈ s
V : Set X
h : V ∈ 𝓝 x
h' : V ∩ s = {x}
⊢ {x}ᶜ ∩ V ∩ s = ∅
state_after: no goals
tactic: rw [inter_assoc, h', compl_inter_self]
Theorem: List.takeList_eq_takeListTR
File: .lake/packages/batteries/Batteries/Data/List/Basic.lean

Proof steps:
state_before: ⊢ @takeList = @takeListTR
state_after: case h.h.h
α : Type u_1
xs : List α
ns : List Nat
⊢ xs.takeList ns = xs.takeListTR ns
tactic: funext α xs ns
state_before: case h.h.h
α : Type u_1
xs : List α
ns : List Nat
⊢ xs.takeList ns = xs.takeListTR ns
state_after: case h.h.h
α : Type u_1
xs : List α
ns : List Nat
⊢ xs.takeList ns = takeListTR.go ns xs #[]
tactic: simp [takeListTR]
state_before: α : Type u_1
xs✝ : List α
ns : List Nat
acc : Array (List α)
xs : List α
⊢ takeListTR.go [] xs acc =
    match xs.takeList [] with
    | (l, r) => (acc.toList ++ l, r)
state_after: no goals
tactic: simp [takeListTR.go, takeList]
state_before: α : Type u_1
xs✝ : List α
ns✝ : List Nat
acc : Array (List α)
n : Nat
ns : List Nat
xs : List α
⊢ takeListTR.go (n :: ns) xs acc =
    match xs.takeList (n :: ns) with
    | (l, r) => (acc.toList ++ l, r)
state_after: no goals
tactic: simp [takeListTR.go, takeList, go _ ns]
state_before: case h.h.h
α : Type u_1
xs : List α
ns : List Nat
⊢ xs.takeList ns = takeListTR.go ns xs #[]
state_after: no goals
tactic: simp [takeListTR, go]
Theorem: Polynomial.root_mul_right_of_isRoot
File: Mathlib/Algebra/Polynomial/Eval.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : CommSemiring R
p✝ q✝ : R[X]
x : R
inst✝ : CommSemiring S
f : R →+* S
p q : R[X]
H : p.IsRoot a
⊢ (p * q).IsRoot a
state_after: no goals
tactic: rw [IsRoot, eval_mul, IsRoot.def.1 H, zero_mul]
Theorem: spectrum.zero_mem_resolventSet_of_unit
File: Mathlib/Algebra/Algebra/Spectrum.lean

Proof steps:
state_before: R : Type u
A : Type v
inst✝² : CommSemiring R
inst✝¹ : Ring A
inst✝ : Algebra R A
a : Aˣ
⊢ 0 ∈ resolventSet R ↑a
state_after: no goals
tactic: simpa only [mem_resolventSet_iff, ← not_mem_iff, zero_not_mem_iff] using a.isUnit
Theorem: integral_sin_pow
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

Proof steps:
state_before: a b : ℝ
n : ℕ
⊢ ∫ (x : ℝ) in a..b, sin x ^ (n + 2) =
    (sin a ^ (n + 1) * cos a - sin b ^ (n + 1) * cos b) / (↑n + 2) + (↑n + 1) / (↑n + 2) * ∫ (x : ℝ) in a..b, sin x ^ n
state_after: a b : ℝ
n : ℕ
⊢ (∫ (x : ℝ) in a..b, sin x ^ (n + 2)) * (↑n + 2) =
    sin a ^ (n + 1) * cos a - sin b ^ (n + 1) * cos b + (↑n + 1) * ∫ (x : ℝ) in a..b, sin x ^ n
tactic: field_simp
state_before: a b : ℝ
n : ℕ
⊢ (∫ (x : ℝ) in a..b, sin x ^ (n + 2)) * (↑n + 2) =
    sin a ^ (n + 1) * cos a - sin b ^ (n + 1) * cos b + (↑n + 1) * ∫ (x : ℝ) in a..b, sin x ^ n
state_after: case h.e'_2
a b : ℝ
n : ℕ
⊢ (∫ (x : ℝ) in a..b, sin x ^ (n + 2)) * (↑n + 2) =
    (∫ (x : ℝ) in a..b, sin x ^ (n + 2)) + (↑n + 1) * ∫ (x : ℝ) in a..b, sin x ^ (n + 2)
tactic: convert eq_sub_iff_add_eq.mp (integral_sin_pow_aux n) using 1
state_before: case h.e'_2
a b : ℝ
n : ℕ
⊢ (∫ (x : ℝ) in a..b, sin x ^ (n + 2)) * (↑n + 2) =
    (∫ (x : ℝ) in a..b, sin x ^ (n + 2)) + (↑n + 1) * ∫ (x : ℝ) in a..b, sin x ^ (n + 2)
state_after: no goals
tactic: ring
Theorem: Mathlib.Vector.scanl_head
File: Mathlib/Data/Vector/Basic.lean

Proof steps:
state_before: n : ℕ
α : Type u_1
β : Type u_2
f : β → α → β
b : β
v : Vector α n
⊢ (scanl f b v).head = b
state_after: case zero
α : Type u_1
β : Type u_2
f : β → α → β
b : β
v : Vector α 0
⊢ (scanl f b v).head = b

case succ
α : Type u_1
β : Type u_2
f : β → α → β
b : β
n✝ : ℕ
v : Vector α (n✝ + 1)
⊢ (scanl f b v).head = b
tactic: cases n
Theorem: MeasureTheory.Measure.restrict_congr_mono
File: Mathlib/MeasureTheory/Measure/Restrict.lean

Proof steps:
state_before: R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
hs : s ⊆ t
h : μ.restrict t = ν.restrict t
⊢ μ.restrict s = ν.restrict s
state_after: no goals
tactic: rw [← restrict_restrict_of_subset hs, h, restrict_restrict_of_subset hs]
Theorem: TopologicalSpace.IsTopologicalBasis.inducing
File: Mathlib/Topology/Bases.lean

Proof steps:
state_before: α : Type u
β✝ : Type u_1
t : TopologicalSpace α
B : Set (Set α)
s : Set α
β : Type u_2
inst✝ : TopologicalSpace β
f : α → β
T : Set (Set β)
hf : Inducing f
h : IsTopologicalBasis T
a : α
⊢ (𝓝 a).HasBasis (fun t => t ∈ preimage f '' T ∧ a ∈ t) id
state_after: case h.e'_4.h.a
α : Type u
β✝ : Type u_1
t : TopologicalSpace α
B : Set (Set α)
s✝ : Set α
β : Type u_2
inst✝ : TopologicalSpace β
f : α → β
T : Set (Set β)
hf : Inducing f
h : IsTopologicalBasis T
a : α
s : Set α
⊢ s ∈ preimage f '' T ∧ a ∈ s ↔ s ∈ (preimage f ∘ fun t => t) '' {i | i ∈ T ∧ f a ∈ i}
tactic: convert (hf.basis_nhds (h.nhds_hasBasis (a := f a))).to_image_id with s
state_before: case h.e'_4.h.a
α : Type u
β✝ : Type u_1
t : TopologicalSpace α
B : Set (Set α)
s✝ : Set α
β : Type u_2
inst✝ : TopologicalSpace β
f : α → β
T : Set (Set β)
hf : Inducing f
h : IsTopologicalBasis T
a : α
s : Set α
⊢ s ∈ preimage f '' T ∧ a ∈ s ↔ s ∈ (preimage f ∘ fun t => t) '' {i | i ∈ T ∧ f a ∈ i}
state_after: no goals
tactic: aesop
Theorem: Finset.prod_dvd_of_isRelPrime
File: Mathlib/RingTheory/Coprime/Lemmas.lean

Proof steps:
state_before: α : Type u_2
I : Type u_1
inst✝¹ : CommMonoid α
inst✝ : DecompositionMonoid α
x y z : α
s : I → α
t : Finset I
⊢ (↑t).Pairwise (IsRelPrime on s) → (∀ i ∈ t, s i ∣ z) → ∏ x ∈ t, s x ∣ z
state_after: no goals
tactic: classical
  exact Finset.induction_on t (fun _ _ ↦ one_dvd z)
    (by
      intro a r har ih Hs Hs1
      rw [Finset.prod_insert har]
      have aux1 : a ∈ (↑(insert a r) : Set I) := Finset.mem_insert_self a r
      refine
        (IsRelPrime.prod_right fun i hir ↦
              Hs aux1 (Finset.mem_insert_of_mem hir) <| by
                rintro rfl
                exact har hir).mul_dvd
          (Hs1 a aux1) (ih (Hs.mono ?_) fun i hi ↦ Hs1 i <| Finset.mem_insert_of_mem hi)
      simp only [Finset.coe_insert, Set.subset_insert])
Theorem: HomologicalComplex.isZero_single_obj_X
File: Mathlib/Algebra/Homology/Single.lean

Proof steps:
state_before: V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
A : V
i : ι
hi : i ≠ j
⊢ IsZero (((single V c j).obj A).X i)
state_after: V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
A : V
i : ι
hi : i ≠ j
⊢ IsZero (if i = j then A else 0)
tactic: dsimp [single]
state_before: V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
A : V
i : ι
hi : i ≠ j
⊢ IsZero (if i = j then A else 0)
state_after: V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
A : V
i : ι
hi : i ≠ j
⊢ IsZero 0
tactic: rw [if_neg hi]
state_before: V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
A : V
i : ι
hi : i ≠ j
⊢ IsZero 0
state_after: no goals
tactic: exact Limits.isZero_zero V
Theorem: ZMod.ringEquivCongr_symm
File: Mathlib/Data/ZMod/Basic.lean

Proof steps:
state_before: n : ℕ
R : Type u_1
inst✝¹ : Ring R
inst✝ : CharP R n
a b : ℕ
hab : a = b
⊢ (ringEquivCongr hab).symm = ringEquivCongr ⋯
state_after: n : ℕ
R : Type u_1
inst✝¹ : Ring R
inst✝ : CharP R n
a : ℕ
⊢ (ringEquivCongr ⋯).symm = ringEquivCongr ⋯
tactic: subst hab
state_before: n : ℕ
R : Type u_1
inst✝¹ : Ring R
inst✝ : CharP R n
a : ℕ
⊢ (ringEquivCongr ⋯).symm = ringEquivCongr ⋯
state_after: no goals
tactic: cases a <;> rfl
Theorem: MvPolynomial.coeff_single_X
File: Mathlib/Algebra/MvPolynomial/Basic.lean

Proof steps:
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n✝ m : σ
s✝ : σ →₀ ℕ
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
p q : MvPolynomial σ R
inst✝ : DecidableEq σ
s s' : σ
n : ℕ
⊢ coeff (Finsupp.single s' n) (X s) = if n = 1 ∧ s = s' then 1 else 0
state_after: no goals
tactic: simpa [eq_comm, and_comm] using coeff_single_X_pow s s' 1 n
Theorem: AlgebraicGeometry.Scheme.Pullback.pullbackFstιToV_snd
File: Mathlib/AlgebraicGeometry/Pullbacks.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : X.OpenCover
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (𝒰.map i ≫ f) g
s : PullbackCone f g
i j : 𝒰.J
⊢ pullbackFstιToV 𝒰 f g i j ≫ pullback.snd (pullback.fst (𝒰.map j ≫ f) g ≫ 𝒰.map j) (𝒰.map i) =
    pullback.fst (pullback.fst (p1 𝒰 f g) (𝒰.map i)) ((gluing 𝒰 f g).ι j) ≫ pullback.snd (p1 𝒰 f g) (𝒰.map i)
state_after: no goals
tactic: simp [pullbackFstιToV, p1]
Theorem: Int.natAbs_sub_pos_iff
File: Mathlib/Algebra/Order/Group/Int.lean

Proof steps:
state_before: i j : ℤ
⊢ 0 < (i - j).natAbs ↔ i ≠ j
state_after: no goals
tactic: rw [natAbs_pos, ne_eq, sub_eq_zero]
Theorem: AddSubgroup.addSubgroupOf_inj
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁵ : Group G
inst✝⁴ : Group G'
inst✝³ : Group G''
A : Type u_4
inst✝² : AddGroup A
H K✝ : Subgroup G
k : Set G
N : Type u_5
inst✝¹ : Group N
P : Type u_6
inst✝ : Group P
H₁ H₂ K : Subgroup G
⊢ H₁.subgroupOf K = H₂.subgroupOf K ↔ H₁ ⊓ K = H₂ ⊓ K
state_after: no goals
tactic: simpa only [SetLike.ext_iff, mem_inf, mem_subgroupOf, and_congr_left_iff] using Subtype.forall
Theorem: Order.IsSuccLimit.isMin
File: Mathlib/Order/SuccPred/Limit.lean

Proof steps:
state_before: α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : SuccOrder α
a b✝ : α
C : α → Sort u_2
inst✝ : IsSuccArchimedean α
h : IsSuccLimit a
b : α
hb : b ≤ a
⊢ a ≤ b
state_after: α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : SuccOrder α
a b✝ : α
C : α → Sort u_2
inst✝ : IsSuccArchimedean α
b : α
hb : b ≤ a
⊢ IsSuccLimit a → a ≤ b
tactic: revert h
state_before: α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : SuccOrder α
a b✝ : α
C : α → Sort u_2
inst✝ : IsSuccArchimedean α
b : α
hb : b ≤ a
⊢ IsSuccLimit a → a ≤ b
state_after: α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : SuccOrder α
a b✝ : α
C : α → Sort u_2
inst✝ : IsSuccArchimedean α
b : α
hb : b ≤ a
c : α
x✝ : b ≤ c
H : IsSuccLimit c → c ≤ b
hc : IsSuccLimit (succ c)
⊢ succ c ≤ b
tactic: refine Succ.rec (fun _ => le_rfl) (fun c _ H hc => ?_) hb
state_before: α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : SuccOrder α
a b✝ : α
C : α → Sort u_2
inst✝ : IsSuccArchimedean α
b : α
hb : b ≤ a
c : α
x✝ : b ≤ c
H : IsSuccLimit c → c ≤ b
hc : IsSuccLimit (succ c)
⊢ succ c ≤ b
state_after: α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : SuccOrder α
a b✝ : α
C : α → Sort u_2
inst✝ : IsSuccArchimedean α
b : α
hb : b ≤ a
c : α
x✝ : b ≤ c
H : IsSuccLimit c → c ≤ b
hc : IsSuccLimit (succ c)
this : succ c = c
⊢ succ c ≤ b
tactic: have := hc.isMax.succ_eq
state_before: α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : SuccOrder α
a b✝ : α
C : α → Sort u_2
inst✝ : IsSuccArchimedean α
b : α
hb : b ≤ a
c : α
x✝ : b ≤ c
H : IsSuccLimit c → c ≤ b
hc : IsSuccLimit (succ c)
this : succ c = c
⊢ succ c ≤ b
state_after: α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : SuccOrder α
a b✝ : α
C : α → Sort u_2
inst✝ : IsSuccArchimedean α
b : α
hb : b ≤ a
c : α
x✝ : b ≤ c
H : IsSuccLimit c → c ≤ b
hc : IsSuccLimit c
this : succ c = c
⊢ c ≤ b
tactic: rw [this] at hc ⊢
state_before: α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : SuccOrder α
a b✝ : α
C : α → Sort u_2
inst✝ : IsSuccArchimedean α
b : α
hb : b ≤ a
c : α
x✝ : b ≤ c
H : IsSuccLimit c → c ≤ b
hc : IsSuccLimit c
this : succ c = c
⊢ c ≤ b
state_after: no goals
tactic: exact H hc
Theorem: PrincipalIdealRing.mem_submonoid_of_factors_subset_of_units_subset
File: Mathlib/RingTheory/PrincipalIdealDomain.lean

Proof steps:
state_before: R : Type u
M : Type v
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : IsPrincipalIdealRing R
s : Submonoid R
a : R
ha : a ≠ 0
hfac : ∀ b ∈ factors a, b ∈ s
hunit : ∀ (c : Rˣ), ↑c ∈ s
⊢ a ∈ s
state_after: case intro
R : Type u
M : Type v
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : IsPrincipalIdealRing R
s : Submonoid R
a : R
ha : a ≠ 0
hfac : ∀ b ∈ factors a, b ∈ s
hunit : ∀ (c : Rˣ), ↑c ∈ s
c : Rˣ
hc : (factors a).prod * ↑c = a
⊢ a ∈ s
tactic: rcases (factors_spec a ha).2 with ⟨c, hc⟩
state_before: case intro
R : Type u
M : Type v
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : IsPrincipalIdealRing R
s : Submonoid R
a : R
ha : a ≠ 0
hfac : ∀ b ∈ factors a, b ∈ s
hunit : ∀ (c : Rˣ), ↑c ∈ s
c : Rˣ
hc : (factors a).prod * ↑c = a
⊢ a ∈ s
state_after: case intro
R : Type u
M : Type v
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : IsPrincipalIdealRing R
s : Submonoid R
a : R
ha : a ≠ 0
hfac : ∀ b ∈ factors a, b ∈ s
hunit : ∀ (c : Rˣ), ↑c ∈ s
c : Rˣ
hc : (factors a).prod * ↑c = a
⊢ (factors a).prod * ↑c ∈ s
tactic: rw [← hc]
state_before: case intro
R : Type u
M : Type v
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : IsPrincipalIdealRing R
s : Submonoid R
a : R
ha : a ≠ 0
hfac : ∀ b ∈ factors a, b ∈ s
hunit : ∀ (c : Rˣ), ↑c ∈ s
c : Rˣ
hc : (factors a).prod * ↑c = a
⊢ (factors a).prod * ↑c ∈ s
state_after: no goals
tactic: exact mul_mem (multiset_prod_mem _ hfac) (hunit _)
Theorem: Nat.totient_prime_pow
File: Mathlib/Data/Nat/Totient.lean

Proof steps:
state_before: p : ℕ
hp : Prime p
n : ℕ
hn : 0 < n
⊢ φ (p ^ n) = p ^ (n - 1) * (p - 1)
state_after: case intro
p : ℕ
hp : Prime p
m : ℕ
hn : 0 < m.succ
⊢ φ (p ^ m.succ) = p ^ (m.succ - 1) * (p - 1)
tactic: rcases exists_eq_succ_of_ne_zero (pos_iff_ne_zero.1 hn) with ⟨m, rfl⟩
state_before: case intro
p : ℕ
hp : Prime p
m : ℕ
hn : 0 < m.succ
⊢ φ (p ^ m.succ) = p ^ (m.succ - 1) * (p - 1)
state_after: no goals
tactic: exact totient_prime_pow_succ hp _
Theorem: Matrix.add_mulVec
File: Mathlib/Data/Matrix/Basic.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype n
A B : Matrix m n α
x : n → α
⊢ (A + B) *ᵥ x = A *ᵥ x + B *ᵥ x
state_after: case h
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype n
A B : Matrix m n α
x : n → α
x✝ : m
⊢ ((A + B) *ᵥ x) x✝ = (A *ᵥ x + B *ᵥ x) x✝
tactic: ext
state_before: case h
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype n
A B : Matrix m n α
x : n → α
x✝ : m
⊢ ((A + B) *ᵥ x) x✝ = (A *ᵥ x + B *ᵥ x) x✝
state_after: no goals
tactic: apply add_dotProduct
Theorem: EMetric.infEdist_pos_iff_not_mem_closure
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x✝ y : α
s t : Set α
Φ : α → β
x : α
E : Set α
⊢ 0 < infEdist x E ↔ x ∉ closure E
state_after: no goals
tactic: rw [mem_closure_iff_infEdist_zero, pos_iff_ne_zero]
Theorem: PathConnectedSpace.exists_path_through_family
File: Mathlib/Topology/Connected/PathConnected.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
x y z : X
ι : Type u_3
F : Set X
inst✝ : PathConnectedSpace X
n : ℕ
p : Fin (n + 1) → X
⊢ ∃ γ, ∀ (i : Fin (n + 1)), p i ∈ range ⇑γ
state_after: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
x y z : X
ι : Type u_3
F : Set X
inst✝ : PathConnectedSpace X
n : ℕ
p : Fin (n + 1) → X
this : IsPathConnected univ
⊢ ∃ γ, ∀ (i : Fin (n + 1)), p i ∈ range ⇑γ
tactic: have : IsPathConnected (univ : Set X) := pathConnectedSpace_iff_univ.mp (by infer_instance)
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
x y z : X
ι : Type u_3
F : Set X
inst✝ : PathConnectedSpace X
n : ℕ
p : Fin (n + 1) → X
this : IsPathConnected univ
⊢ ∃ γ, ∀ (i : Fin (n + 1)), p i ∈ range ⇑γ
state_after: case intro.intro
X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
x y z : X
ι : Type u_3
F : Set X
inst✝ : PathConnectedSpace X
n : ℕ
p : Fin (n + 1) → X
this : IsPathConnected univ
γ : Path (p 0) (p ↑n)
h : ∀ (i : Fin (n + 1)), p i ∈ range ⇑γ
⊢ ∃ γ, ∀ (i : Fin (n + 1)), p i ∈ range ⇑γ
tactic: rcases this.exists_path_through_family p fun _i => True.intro with ⟨γ, -, h⟩
state_before: case intro.intro
X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
x y z : X
ι : Type u_3
F : Set X
inst✝ : PathConnectedSpace X
n : ℕ
p : Fin (n + 1) → X
this : IsPathConnected univ
γ : Path (p 0) (p ↑n)
h : ∀ (i : Fin (n + 1)), p i ∈ range ⇑γ
⊢ ∃ γ, ∀ (i : Fin (n + 1)), p i ∈ range ⇑γ
state_after: no goals
tactic: exact ⟨γ, h⟩
Theorem: MeasureTheory.isometry_lpMeasSubgroupToLpTrim
File: Mathlib/MeasureTheory/Function/ConditionalExpectation/AEMeasurable.lean

Proof steps:
state_before: α : Type u_1
E' : Type u_2
F : Type u_3
F' : Type u_4
𝕜 : Type u_5
p : ℝ≥0∞
inst✝¹⁰ : RCLike 𝕜
inst✝⁹ : NormedAddCommGroup E'
inst✝⁸ : InnerProductSpace 𝕜 E'
inst✝⁷ : CompleteSpace E'
inst✝⁶ : NormedSpace ℝ E'
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace 𝕜 F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : CompleteSpace F'
ι : Type u_6
m m0 : MeasurableSpace α
μ : Measure α
hp : Fact (1 ≤ p)
hm : m ≤ m0
f g : ↥(lpMeasSubgroup F m p μ)
⊢ dist (lpMeasSubgroupToLpTrim F p μ hm f) (lpMeasSubgroupToLpTrim F p μ hm g) = dist f g
state_after: no goals
tactic: rw [dist_eq_norm, ← lpMeasSubgroupToLpTrim_sub, lpMeasSubgroupToLpTrim_norm_map,
      dist_eq_norm]