ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: IsSelfAdjoint.eq_smul_self_of_isLocalExtrOn
File: Mathlib/Analysis/InnerProductSpace/Rayleigh.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝³ : RCLike 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : CompleteSpace E
T : E →L[𝕜] E
hT : IsSelfAdjoint T
x₀ : E
hextr : IsLocalExtrOn T.reApplyInnerSelf (sphere 0 ‖x₀‖) x₀
⊢ T x₀ = ↑(T.rayleighQuotient x₀) • x₀
state_after: 𝕜 : Type u_1
inst✝³ : RCLike 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : CompleteSpace E
T : E →L[𝕜] E
hT : IsSelfAdjoint T
x₀ : E
hextr : IsLocalExtrOn T.reApplyInnerSelf (sphere 0 ‖x₀‖) x₀
this : InnerProductSpace ℝ E := InnerProductSpace.rclikeToReal 𝕜 E
⊢ T x₀ = ↑(T.rayleighQuotient x₀) • x₀
tactic: letI := InnerProductSpace.rclikeToReal 𝕜 E
state_before: 𝕜 : Type u_1
inst✝³ : RCLike 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : CompleteSpace E
T : E →L[𝕜] E
hT : IsSelfAdjoint T
x₀ : E
hextr : IsLocalExtrOn T.reApplyInnerSelf (sphere 0 ‖x₀‖) x₀
this : InnerProductSpace ℝ E := InnerProductSpace.rclikeToReal 𝕜 E
⊢ T x₀ = ↑(T.rayleighQuotient x₀) • x₀
state_after: 𝕜 : Type u_1
inst✝³ : RCLike 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : CompleteSpace E
T : E →L[𝕜] E
hT : IsSelfAdjoint T
x₀ : E
hextr : IsLocalExtrOn T.reApplyInnerSelf (sphere 0 ‖x₀‖) x₀
this : InnerProductSpace ℝ E := InnerProductSpace.rclikeToReal 𝕜 E
hSA : ↑⋯.toSelfAdjoint ∈ selfAdjoint (E →L[ℝ] E) :=
  Subtype.prop (LinearMap.IsSymmetric.restrictScalars (isSymmetric hT)).toSelfAdjoint
⊢ T x₀ = ↑(T.rayleighQuotient x₀) • x₀
tactic: let hSA := hT.isSymmetric.restrictScalars.toSelfAdjoint.prop
state_before: 𝕜 : Type u_1
inst✝³ : RCLike 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : CompleteSpace E
T : E →L[𝕜] E
hT : IsSelfAdjoint T
x₀ : E
hextr : IsLocalExtrOn T.reApplyInnerSelf (sphere 0 ‖x₀‖) x₀
this : InnerProductSpace ℝ E := InnerProductSpace.rclikeToReal 𝕜 E
hSA : ↑⋯.toSelfAdjoint ∈ selfAdjoint (E →L[ℝ] E) :=
  Subtype.prop (LinearMap.IsSymmetric.restrictScalars (isSymmetric hT)).toSelfAdjoint
⊢ T x₀ = ↑(T.rayleighQuotient x₀) • x₀
state_after: no goals
tactic: exact hSA.eq_smul_self_of_isLocalExtrOn_real hextr
Theorem: CategoryTheory.OplaxFunctor.bicategory_comp_naturality
File: Mathlib/CategoryTheory/Bicategory/FunctorBicategory.lean

Proof steps:
state_before: B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H I a b c : OplaxFunctor B C
f g : a ⟶ b
h i : b ⟶ c
η : f ⟶ g
θ : h ⟶ i
⊢ (fun {F G H} η x x_1 Γ => OplaxNatTrans.whiskerLeft η Γ) f h i θ ≫
      (fun {F G H} x x_1 Γ η => OplaxNatTrans.whiskerRight Γ η) f g η i =
    (fun {F G H} x x_1 Γ η => OplaxNatTrans.whiskerRight Γ η) f g η h ≫
      (fun {F G H} η x x_1 Γ => OplaxNatTrans.whiskerLeft η Γ) g h i θ
state_after: case w
B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H I a b c : OplaxFunctor B C
f g : a ⟶ b
h i : b ⟶ c
η : f ⟶ g
θ : h ⟶ i
b✝ : B
⊢ ((fun {F G H} η x x_1 Γ => OplaxNatTrans.whiskerLeft η Γ) f h i θ ≫
          (fun {F G H} x x_1 Γ η => OplaxNatTrans.whiskerRight Γ η) f g η i).app
      b✝ =
    ((fun {F G H} x x_1 Γ η => OplaxNatTrans.whiskerRight Γ η) f g η h ≫
          (fun {F G H} η x x_1 Γ => OplaxNatTrans.whiskerLeft η Γ) g h i θ).app
      b✝
tactic: ext
state_before: case w
B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H I a b c : OplaxFunctor B C
f g : a ⟶ b
h i : b ⟶ c
η : f ⟶ g
θ : h ⟶ i
b✝ : B
⊢ ((fun {F G H} η x x_1 Γ => OplaxNatTrans.whiskerLeft η Γ) f h i θ ≫
          (fun {F G H} x x_1 Γ η => OplaxNatTrans.whiskerRight Γ η) f g η i).app
      b✝ =
    ((fun {F G H} x x_1 Γ η => OplaxNatTrans.whiskerRight Γ η) f g η h ≫
          (fun {F G H} η x x_1 Γ => OplaxNatTrans.whiskerLeft η Γ) g h i θ).app
      b✝
state_after: no goals
tactic: exact whisker_exchange _ _
Theorem: pow_dvd_pow
File: Mathlib/Algebra/Divisibility/Basic.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Monoid α
a✝ b c : α
m n : ℕ
a : α
h : m ≤ n
⊢ a ^ n = a ^ m * a ^ (n - m)
state_after: no goals
tactic: rw [← pow_add, Nat.add_comm, Nat.sub_add_cancel h]
Theorem: AbstractCompletion.map_unique
File: Mathlib/Topology/UniformSpace/AbstractCompletion.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : UniformSpace α
pkg : AbstractCompletion α
β : Type u_2
inst✝ : UniformSpace β
pkg' : AbstractCompletion β
f✝ f : α → β
g : pkg.space → pkg'.space
hg : UniformContinuous g
h : ∀ (a : α), pkg'.coe (f a) = g (pkg.coe a)
⊢ ∀ (a : α), pkg.map pkg' f (pkg.coe a) = g (pkg.coe a)
state_after: α : Type u_1
inst✝¹ : UniformSpace α
pkg : AbstractCompletion α
β : Type u_2
inst✝ : UniformSpace β
pkg' : AbstractCompletion β
f✝ f : α → β
g : pkg.space → pkg'.space
hg : UniformContinuous g
h : ∀ (a : α), pkg'.coe (f a) = g (pkg.coe a)
a : α
⊢ pkg.map pkg' f (pkg.coe a) = g (pkg.coe a)
tactic: intro a
state_before: α : Type u_1
inst✝¹ : UniformSpace α
pkg : AbstractCompletion α
β : Type u_2
inst✝ : UniformSpace β
pkg' : AbstractCompletion β
f✝ f : α → β
g : pkg.space → pkg'.space
hg : UniformContinuous g
h : ∀ (a : α), pkg'.coe (f a) = g (pkg.coe a)
a : α
⊢ pkg.map pkg' f (pkg.coe a) = g (pkg.coe a)
state_after: α : Type u_1
inst✝¹ : UniformSpace α
pkg : AbstractCompletion α
β : Type u_2
inst✝ : UniformSpace β
pkg' : AbstractCompletion β
f✝ f : α → β
g : pkg.space → pkg'.space
hg : UniformContinuous g
h : ∀ (a : α), pkg'.coe (f a) = g (pkg.coe a)
a : α
⊢ pkg.extend (pkg'.coe ∘ f) (pkg.coe a) = g (pkg.coe a)
tactic: change pkg.extend (ι' ∘ f) _ = _
state_before: α : Type u_1
inst✝¹ : UniformSpace α
pkg : AbstractCompletion α
β : Type u_2
inst✝ : UniformSpace β
pkg' : AbstractCompletion β
f✝ f : α → β
g : pkg.space → pkg'.space
hg : UniformContinuous g
h : ∀ (a : α), pkg'.coe (f a) = g (pkg.coe a)
a : α
⊢ pkg.extend (fun x => (g ∘ pkg.coe) x) (pkg.coe a) = (g ∘ pkg.coe) a
state_after: no goals
tactic: rw [pkg.extend_coe (hg.comp pkg.uniformContinuous_coe)]
Theorem: Stream'.bisim_simple
File: Mathlib/Data/Stream/Init.lean

Proof steps:
state_before: α : Type u
β : Type v
δ : Type w
s₁✝ s₂✝ : Stream' α
hh : s₁✝.head = s₂✝.head
ht₁ : s₁✝ = s₁✝.tail
ht₂ : s₂✝ = s₂✝.tail
s₁ s₂ : Stream' α
x✝ : (fun s₁ s₂ => s₁.head = s₂.head ∧ s₁ = s₁.tail ∧ s₂ = s₂.tail) s₁ s₂
h₁ : s₁.head = s₂.head
h₂ : s₁ = s₁.tail
h₃ : s₂ = s₂.tail
⊢ s₁.head = s₂.head ∧ (fun s₁ s₂ => s₁.head = s₂.head ∧ s₁ = s₁.tail ∧ s₂ = s₂.tail) s₁.tail s₂.tail
state_after: case left
α : Type u
β : Type v
δ : Type w
s₁✝ s₂✝ : Stream' α
hh : s₁✝.head = s₂✝.head
ht₁ : s₁✝ = s₁✝.tail
ht₂ : s₂✝ = s₂✝.tail
s₁ s₂ : Stream' α
x✝ : (fun s₁ s₂ => s₁.head = s₂.head ∧ s₁ = s₁.tail ∧ s₂ = s₂.tail) s₁ s₂
h₁ : s₁.head = s₂.head
h₂ : s₁ = s₁.tail
h₃ : s₂ = s₂.tail
⊢ s₁.head = s₂.head

case right
α : Type u
β : Type v
δ : Type w
s₁✝ s₂✝ : Stream' α
hh : s₁✝.head = s₂✝.head
ht₁ : s₁✝ = s₁✝.tail
ht₂ : s₂✝ = s₂✝.tail
s₁ s₂ : Stream' α
x✝ : (fun s₁ s₂ => s₁.head = s₂.head ∧ s₁ = s₁.tail ∧ s₂ = s₂.tail) s₁ s₂
h₁ : s₁.head = s₂.head
h₂ : s₁ = s₁.tail
h₃ : s₂ = s₂.tail
⊢ (fun s₁ s₂ => s₁.head = s₂.head ∧ s₁ = s₁.tail ∧ s₂ = s₂.tail) s₁.tail s₂.tail
tactic: constructor
state_before: case right
α : Type u
β : Type v
δ : Type w
s₁✝ s₂✝ : Stream' α
hh : s₁✝.head = s₂✝.head
ht₁ : s₁✝ = s₁✝.tail
ht₂ : s₂✝ = s₂✝.tail
s₁ s₂ : Stream' α
x✝ : (fun s₁ s₂ => s₁.head = s₂.head ∧ s₁ = s₁.tail ∧ s₂ = s₂.tail) s₁ s₂
h₁ : s₁.head = s₂.head
h₂ : s₁ = s₁.tail
h₃ : s₂ = s₂.tail
⊢ (fun s₁ s₂ => s₁.head = s₂.head ∧ s₁ = s₁.tail ∧ s₂ = s₂.tail) s₁.tail s₂.tail
state_after: case right
α : Type u
β : Type v
δ : Type w
s₁✝ s₂✝ : Stream' α
hh : s₁✝.head = s₂✝.head
ht₁ : s₁✝ = s₁✝.tail
ht₂ : s₂✝ = s₂✝.tail
s₁ s₂ : Stream' α
x✝ : (fun s₁ s₂ => s₁.head = s₂.head ∧ s₁ = s₁.tail ∧ s₂ = s₂.tail) s₁ s₂
h₁ : s₁.head = s₂.head
h₂ : s₁ = s₁.tail
h₃ : s₂ = s₂.tail
⊢ (fun s₁ s₂ => s₁.head = s₂.head ∧ s₁ = s₁.tail ∧ s₂ = s₂.tail) s₁ s₂
tactic: rw [← h₂, ← h₃]
state_before: case right
α : Type u
β : Type v
δ : Type w
s₁✝ s₂✝ : Stream' α
hh : s₁✝.head = s₂✝.head
ht₁ : s₁✝ = s₁✝.tail
ht₂ : s₂✝ = s₂✝.tail
s₁ s₂ : Stream' α
x✝ : (fun s₁ s₂ => s₁.head = s₂.head ∧ s₁ = s₁.tail ∧ s₂ = s₂.tail) s₁ s₂
h₁ : s₁.head = s₂.head
h₂ : s₁ = s₁.tail
h₃ : s₂ = s₂.tail
⊢ (fun s₁ s₂ => s₁.head = s₂.head ∧ s₁ = s₁.tail ∧ s₂ = s₂.tail) s₁ s₂
state_after: no goals
tactic: (repeat' constructor) <;> assumption
Theorem: Equiv.prodCongr_refl_left
File: Mathlib/Logic/Equiv/Basic.lean

Proof steps:
state_before: α₁ : Type u_3
β₁ : Type u_1
β₂ : Type u_2
e✝ : α₁ → β₁ ≃ β₂
e : β₁ ≃ β₂
⊢ (Equiv.refl α₁).prodCongr e = prodCongrRight fun x => e
state_after: case H.mk
α₁ : Type u_3
β₁ : Type u_1
β₂ : Type u_2
e✝ : α₁ → β₁ ≃ β₂
e : β₁ ≃ β₂
a : α₁
b : β₁
⊢ ((Equiv.refl α₁).prodCongr e) (a, b) = (prodCongrRight fun x => e) (a, b)
tactic: ext ⟨a, b⟩ : 1
state_before: case H.mk
α₁ : Type u_3
β₁ : Type u_1
β₂ : Type u_2
e✝ : α₁ → β₁ ≃ β₂
e : β₁ ≃ β₂
a : α₁
b : β₁
⊢ ((Equiv.refl α₁).prodCongr e) (a, b) = (prodCongrRight fun x => e) (a, b)
state_after: no goals
tactic: simp
Theorem: StarConvex.add
File: Mathlib/Analysis/Convex/Star.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y z : E
s t : Set E
hs : StarConvex 𝕜 x s
ht : StarConvex 𝕜 y t
⊢ StarConvex 𝕜 (x + y) (s + t)
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y z : E
s t : Set E
hs : StarConvex 𝕜 x s
ht : StarConvex 𝕜 y t
⊢ StarConvex 𝕜 (x + y) ((fun x => x.1 + x.2) '' s ×ˢ t)
tactic: rw [← add_image_prod]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y z : E
s t : Set E
hs : StarConvex 𝕜 x s
ht : StarConvex 𝕜 y t
⊢ StarConvex 𝕜 (x + y) ((fun x => x.1 + x.2) '' s ×ˢ t)
state_after: no goals
tactic: exact (hs.prod ht).is_linear_image IsLinearMap.isLinearMap_add
Theorem: Mathlib.Meta.NormNum.IsInt.to_isRat
File: Mathlib/Tactic/NormNum/Result.lean

Proof steps:
state_before: α✝ : Type u
u : Level
α : Type u_1
inst✝ : Ring α
n✝ : ℤ
⊢ 1 * ↑1 = 1
state_after: no goals
tactic: simp
state_before: α✝ : Type u
u : Level
α : Type u_1
inst✝ : Ring α
n✝ : ℤ
⊢ ↑1 * 1 = 1
state_after: no goals
tactic: simp
state_before: α✝ : Type u
u : Level
α : Type u_1
inst✝ : Ring α
n✝ : ℤ
⊢ ↑n✝ = ↑n✝ * ⅟↑1
state_after: no goals
tactic: simp
Theorem: PrimeSpectrum.isClosed_iff_zeroLocus
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
Z : Set (PrimeSpectrum R)
⊢ IsClosed Z ↔ ∃ s, Z = zeroLocus s
state_after: no goals
tactic: rw [← isOpen_compl_iff, isOpen_iff, compl_compl]
Theorem: DMatrix.map_add
File: Mathlib/Data/Matrix/DMatrix.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
α : m → n → Type v
inst✝¹ : (i : m) → (j : n) → AddMonoid (α i j)
β : m → n → Type w
inst✝ : (i : m) → (j : n) → AddMonoid (β i j)
f : ⦃i : m⦄ → ⦃j : n⦄ → α i j →+ β i j
M N : DMatrix m n α
⊢ ((M + N).map fun i j => ⇑f) = (M.map fun i j => ⇑f) + N.map fun i j => ⇑f
state_after: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
α : m → n → Type v
inst✝¹ : (i : m) → (j : n) → AddMonoid (α i j)
β : m → n → Type w
inst✝ : (i : m) → (j : n) → AddMonoid (β i j)
f : ⦃i : m⦄ → ⦃j : n⦄ → α i j →+ β i j
M N : DMatrix m n α
i✝ : m
j✝ : n
⊢ (M + N).map (fun i j => ⇑f) i✝ j✝ = ((M.map fun i j => ⇑f) + N.map fun i j => ⇑f) i✝ j✝
tactic: ext
state_before: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
α : m → n → Type v
inst✝¹ : (i : m) → (j : n) → AddMonoid (α i j)
β : m → n → Type w
inst✝ : (i : m) → (j : n) → AddMonoid (β i j)
f : ⦃i : m⦄ → ⦃j : n⦄ → α i j →+ β i j
M N : DMatrix m n α
i✝ : m
j✝ : n
⊢ (M + N).map (fun i j => ⇑f) i✝ j✝ = ((M.map fun i j => ⇑f) + N.map fun i j => ⇑f) i✝ j✝
state_after: no goals
tactic: simp
Theorem: Real.log_div
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

Proof steps:
state_before: x y : ℝ
hx : x ≠ 0
hy : y ≠ 0
⊢ rexp (log (x / y)) = rexp (log x - log y)
state_after: no goals
tactic: rw [exp_log_eq_abs (div_ne_zero hx hy), exp_sub, exp_log_eq_abs hx, exp_log_eq_abs hy, abs_div]
Theorem: Finsupp.mapRange_add
File: Mathlib/Data/Finsupp/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝¹ : AddZeroClass M
inst✝ : AddZeroClass N
f : M → N
hf : f 0 = 0
hf' : ∀ (x y : M), f (x + y) = f x + f y
v₁ v₂ : α →₀ M
x✝ : α
⊢ (mapRange f hf (v₁ + v₂)) x✝ = (mapRange f hf v₁ + mapRange f hf v₂) x✝
state_after: no goals
tactic: simp only [hf', add_apply, mapRange_apply]
Theorem: Fintype.one_lt_prod_iff_of_one_le
File: Mathlib/Algebra/Order/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝¹ : Fintype ι
inst✝ : OrderedCancelCommMonoid M
f : ι → M
hf : 1 ≤ f
⊢ 1 < ∏ i : ι, f i ↔ 1 < f
state_after: no goals
tactic: obtain rfl | hf := hf.eq_or_lt <;> simp [*, one_lt_prod]
Theorem: Real.inv_one_add_tan_sq
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x✝ y x : ℝ
hx : cos x ≠ 0
this : Complex.cos ↑x ≠ 0
⊢ ↑(1 + tan x ^ 2)⁻¹ = ↑(cos x ^ 2)
state_after: no goals
tactic: simpa using Complex.inv_one_add_tan_sq this
Theorem: SimpleGraph.is3Clique_iff
File: Mathlib/Combinatorics/SimpleGraph/Clique.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
s : Finset α
a b c : α
inst✝ : DecidableEq α
⊢ G.IsNClique 3 s ↔ ∃ a b c, G.Adj a b ∧ G.Adj a c ∧ G.Adj b c ∧ s = {a, b, c}
state_after: case refine_1
α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
s : Finset α
a b c : α
inst✝ : DecidableEq α
h : G.IsNClique 3 s
⊢ ∃ a b c, G.Adj a b ∧ G.Adj a c ∧ G.Adj b c ∧ s = {a, b, c}

case refine_2
α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
s : Finset α
a b c : α
inst✝ : DecidableEq α
⊢ (∃ a b c, G.Adj a b ∧ G.Adj a c ∧ G.Adj b c ∧ s = {a, b, c}) → G.IsNClique 3 s
tactic: refine ⟨fun h ↦ ?_, ?_⟩
Theorem: CategoryTheory.ShortComplex.π_homologyMap_ι
File: Mathlib/Algebra/Homology/ShortComplex/Homology.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ✝ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
A : C
inst✝² : S.HasHomology
inst✝¹ : S₁.HasHomology
inst✝ : S₂.HasHomology
φ : S₁ ⟶ S₂
⊢ S₁.homologyπ ≫ homologyMap φ ≫ S₂.homologyι = S₁.iCycles ≫ φ.τ₂ ≫ S₂.pOpcycles
state_after: no goals
tactic: simp only [homologyι_naturality, homology_π_ι_assoc, p_opcyclesMap]
Theorem: AffineMap.restrict.linear_aux
File: Mathlib/LinearAlgebra/AffineSpace/Restrict.lean

Proof steps:
state_before: k : Type u_1
V₁ : Type u_2
P₁ : Type u_3
V₂ : Type u_4
P₂ : Type u_5
inst✝⁶ : Ring k
inst✝⁵ : AddCommGroup V₁
inst✝⁴ : AddCommGroup V₂
inst✝³ : Module k V₁
inst✝² : Module k V₂
inst✝¹ : AddTorsor V₁ P₁
inst✝ : AddTorsor V₂ P₂
φ : P₁ →ᵃ[k] P₂
E : AffineSubspace k P₁
F : AffineSubspace k P₂
hEF : AffineSubspace.map φ E ≤ F
⊢ E.direction ≤ Submodule.comap φ.linear F.direction
state_after: k : Type u_1
V₁ : Type u_2
P₁ : Type u_3
V₂ : Type u_4
P₂ : Type u_5
inst✝⁶ : Ring k
inst✝⁵ : AddCommGroup V₁
inst✝⁴ : AddCommGroup V₂
inst✝³ : Module k V₁
inst✝² : Module k V₂
inst✝¹ : AddTorsor V₁ P₁
inst✝ : AddTorsor V₂ P₂
φ : P₁ →ᵃ[k] P₂
E : AffineSubspace k P₁
F : AffineSubspace k P₂
hEF : AffineSubspace.map φ E ≤ F
⊢ (AffineSubspace.map φ E).direction ≤ F.direction
tactic: rw [← Submodule.map_le_iff_le_comap, ← AffineSubspace.map_direction]
state_before: k : Type u_1
V₁ : Type u_2
P₁ : Type u_3
V₂ : Type u_4
P₂ : Type u_5
inst✝⁶ : Ring k
inst✝⁵ : AddCommGroup V₁
inst✝⁴ : AddCommGroup V₂
inst✝³ : Module k V₁
inst✝² : Module k V₂
inst✝¹ : AddTorsor V₁ P₁
inst✝ : AddTorsor V₂ P₂
φ : P₁ →ᵃ[k] P₂
E : AffineSubspace k P₁
F : AffineSubspace k P₂
hEF : AffineSubspace.map φ E ≤ F
⊢ (AffineSubspace.map φ E).direction ≤ F.direction
state_after: no goals
tactic: exact AffineSubspace.direction_le hEF
Theorem: LieSubmodule.coe_toEnd_pow
File: Mathlib/Algebra/Lie/OfAssociative.lean

Proof steps:
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N : LieSubmodule R L M
x : L
y : ↥N
n : ℕ
⊢ ↑(((toEnd R L ↥↑N) x ^ n) y) = ((toEnd R L M) x ^ n) ↑y
state_after: no goals
tactic: induction n generalizing y with
  | zero => rfl
  | succ n ih => simp only [pow_succ', LinearMap.mul_apply, ih, LieSubmodule.coe_toEnd]
Theorem: Finmap.keys_erase
File: Mathlib/Data/Finmap.lean

Proof steps:
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
s✝ : Finmap β
s : AList β
⊢ (erase a ⟦s⟧).keys = ⟦s⟧.keys.erase a
state_after: no goals
tactic: simp
Theorem: Combinatorics.Subspace.apply_inl
File: Mathlib/Combinatorics/HalesJewett.lean

Proof steps:
state_before: η✝ : Type u_1
α✝ : Type u_2
ι✝ : Type u_3
κ✝ : Type u_4
η : Type u_5
α : Type u_6
ι : Type u_7
κ : Type u_8
l : Subspace η α ι
x : η → α
i : ι
a : α
e : η
h : l.idxFun i = Sum.inl a
⊢ ↑l x i = a
state_after: no goals
tactic: simp [apply_def, h]
Theorem: Batteries.RBNode.Balanced.balRight
File: .lake/packages/batteries/Batteries/Data/RBMap/WF.lean

Proof steps:
state_before: α✝ : Type u_1
l : RBNode α✝
v : α✝
r : RBNode α✝
cl : RBColor
n : Nat
hl : l.Balanced cl (n + 1)
hr : RedRed True r n
⊢ RedRed (cl = red) (l.balRight v r) (n + 1)
state_after: α✝ : Type u_1
l : RBNode α✝
v : α✝
r : RBNode α✝
cl : RBColor
n : Nat
hl : l.Balanced cl (n + 1)
hr : RedRed True r n
⊢ RedRed (cl = red) (r.reverse.balLeft v l.reverse).reverse (n + 1)
tactic: rw [← reverse_reverse (balRight ..), reverse_balRight]
state_before: α✝ : Type u_1
l : RBNode α✝
v : α✝
r : RBNode α✝
cl : RBColor
n : Nat
hl : l.Balanced cl (n + 1)
hr : RedRed True r n
⊢ RedRed (cl = red) (r.reverse.balLeft v l.reverse).reverse (n + 1)
state_after: no goals
tactic: exact .reverse <| hl.reverse.balLeft hr.reverse
Theorem: Finset.sorted_last_eq_max'
File: Mathlib/Data/Finset/Sort.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
s : Finset α
h : (sort (fun x x_1 => x ≤ x_1) s).length - 1 < (sort (fun x x_1 => x ≤ x_1) s).length
⊢ s.Nonempty
state_after: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
s : Finset α
h : s.card - 1 < s.card
⊢ s.Nonempty
tactic: rw [length_sort] at h
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
s : Finset α
h : s.card - 1 < s.card
⊢ s.Nonempty
state_after: no goals
tactic: exact card_pos.1 (lt_of_le_of_lt bot_le h)
Theorem: RootPairing.coxeterWeight_zero_iff_isOrthogonal
File: Mathlib/LinearAlgebra/RootSystem/RootPositive.lean

Proof steps:
state_before: ι : Type u_1
R : Type u_2
M : Type u_3
N : Type u_4
inst✝⁵ : LinearOrderedCommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : AddCommGroup N
inst✝¹ : Module R N
P : RootPairing ι R M N
B : M →ₗ[R] M →ₗ[R] R
inst✝ : P.IsRootPositive B
i j : ι
⊢ P.coxeterWeight i j = 0 ↔ P.IsOrthogonal i j
state_after: ι : Type u_1
R : Type u_2
M : Type u_3
N : Type u_4
inst✝⁵ : LinearOrderedCommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : AddCommGroup N
inst✝¹ : Module R N
P : RootPairing ι R M N
B : M →ₗ[R] M →ₗ[R] R
inst✝ : P.IsRootPositive B
i j : ι
⊢ P.pairing i j = 0 ∨ P.pairing j i = 0 ↔ P.IsOrthogonal i j
tactic: rw [coxeterWeight, mul_eq_zero]
state_before: ι : Type u_1
R : Type u_2
M : Type u_3
N : Type u_4
inst✝⁵ : LinearOrderedCommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : AddCommGroup N
inst✝¹ : Module R N
P : RootPairing ι R M N
B : M →ₗ[R] M →ₗ[R] R
inst✝ : P.IsRootPositive B
i j : ι
⊢ P.pairing i j = 0 ∨ P.pairing j i = 0 ↔ P.IsOrthogonal i j
state_after: ι : Type u_1
R : Type u_2
M : Type u_3
N : Type u_4
inst✝⁵ : LinearOrderedCommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : AddCommGroup N
inst✝¹ : Module R N
P : RootPairing ι R M N
B : M →ₗ[R] M →ₗ[R] R
inst✝ : P.IsRootPositive B
i j : ι
h : P.pairing i j = 0 ∨ P.pairing j i = 0
⊢ P.IsOrthogonal i j
tactic: refine ⟨fun h => ?_, fun h => Or.inl h.1⟩
state_before: ι : Type u_1
R : Type u_2
M : Type u_3
N : Type u_4
inst✝⁵ : LinearOrderedCommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : AddCommGroup N
inst✝¹ : Module R N
P : RootPairing ι R M N
B : M →ₗ[R] M →ₗ[R] R
inst✝ : P.IsRootPositive B
i j : ι
h : P.pairing i j = 0 ∨ P.pairing j i = 0
⊢ P.IsOrthogonal i j
state_after: case inl
ι : Type u_1
R : Type u_2
M : Type u_3
N : Type u_4
inst✝⁵ : LinearOrderedCommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : AddCommGroup N
inst✝¹ : Module R N
P : RootPairing ι R M N
B : M →ₗ[R] M →ₗ[R] R
inst✝ : P.IsRootPositive B
i j : ι
h : P.pairing i j = 0
⊢ P.IsOrthogonal i j

case inr
ι : Type u_1
R : Type u_2
M : Type u_3
N : Type u_4
inst✝⁵ : LinearOrderedCommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : AddCommGroup N
inst✝¹ : Module R N
P : RootPairing ι R M N
B : M →ₗ[R] M →ₗ[R] R
inst✝ : P.IsRootPositive B
i j : ι
h : P.pairing j i = 0
⊢ P.IsOrthogonal i j
tactic: rcases h with h | h
Theorem: lcm_mul_right
File: Mathlib/Algebra/GCDMonoid/Basic.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
a b c : α
⊢ lcm (b * a) (c * a) = lcm b c * normalize a
state_after: no goals
tactic: simp only [mul_comm, lcm_mul_left]
Theorem: AffineSubspace.eq_univ_of_subsingleton_span_eq_top
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : Set P
h₁ : s.Subsingleton
h₂ : affineSpan k s = ⊤
⊢ s = univ
state_after: case intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : Set P
h₁ : s.Subsingleton
h₂ : affineSpan k s = ⊤
p : P
hp : p ∈ s
⊢ s = univ
tactic: obtain ⟨p, hp⟩ := AffineSubspace.nonempty_of_affineSpan_eq_top k V P h₂
state_before: case intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : Set P
h₁ : s.Subsingleton
h₂ : affineSpan k s = ⊤
p : P
hp : p ∈ s
⊢ s = univ
state_after: case intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : Set P
h₁ : s.Subsingleton
h₂ : affineSpan k s = ⊤
p : P
hp : p ∈ s
this : s = {p}
⊢ s = univ
tactic: have : s = {p} := Subset.antisymm (fun q hq => h₁ hq hp) (by simp [hp])
state_before: case intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : Set P
h₁ : s.Subsingleton
h₂ : affineSpan k s = ⊤
p : P
hp : p ∈ s
this : s = {p}
⊢ s = univ
state_after: case intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : Set P
h₁ : s.Subsingleton
h₂ : affineSpan k s = ⊤
p : P
hp : p ∈ s
this : s = {p}
⊢ Subsingleton P
tactic: rw [this, eq_comm, ← subsingleton_iff_singleton (mem_univ p), subsingleton_univ_iff]
state_before: case intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : Set P
h₁ : s.Subsingleton
h₂ : affineSpan k s = ⊤
p : P
hp : p ∈ s
this : s = {p}
⊢ Subsingleton P
state_after: no goals
tactic: exact subsingleton_of_subsingleton_span_eq_top h₁ h₂
Theorem: MeasureTheory.IsProbabilityMeasure.ne_zero
File: Mathlib/MeasureTheory/Measure/Typeclasses.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ✝ ν ν₁ ν₂ : Measure α
s t : Set α
μ : Measure α
inst✝ : IsProbabilityMeasure μ
⊢ ¬μ univ = 0
state_after: no goals
tactic: simp [measure_univ]