ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: MeasureTheory.Measure.sigmaFinite_of_countable
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 α
S : Set (Set α)
hc : S.Countable
hμ : ∀ s ∈ S, μ s < ⊤
hU : ⋃₀ S = univ
⊢ SigmaFinite μ
state_after: case intro.intro
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
S : Set (Set α)
hc : S.Countable
hμ✝ : ∀ s ∈ S, μ s < ⊤
hU : ⋃₀ S = univ
s : ℕ → Set α
hμ : ∀ (n : ℕ), μ (s n) < ⊤
hs : ⋃ n, s n = univ
⊢ SigmaFinite μ
tactic: obtain ⟨s, hμ, hs⟩ : ∃ s : ℕ → Set α, (∀ n, μ (s n) < ∞) ∧ ⋃ n, s n = univ :=
    (@exists_seq_cover_iff_countable _ (fun x => μ x < ∞) ⟨∅, by simp⟩).2 ⟨S, hc, hμ, hU⟩
state_before: case intro.intro
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
S : Set (Set α)
hc : S.Countable
hμ✝ : ∀ s ∈ S, μ s < ⊤
hU : ⋃₀ S = univ
s : ℕ → Set α
hμ : ∀ (n : ℕ), μ (s n) < ⊤
hs : ⋃ n, s n = univ
⊢ SigmaFinite μ
state_after: no goals
tactic: exact ⟨⟨⟨fun n => s n, fun _ => trivial, hμ, hs⟩⟩⟩
Theorem: LieAlgebra.IsKilling.lie_eq_smul_of_mem_rootSpace
File: Mathlib/Algebra/Lie/Weights/Killing.lean

Proof steps:
state_before: R : Type u_1
K : Type u_2
L : Type u_3
inst✝⁹ : CommRing R
inst✝⁸ : LieRing L
inst✝⁷ : LieAlgebra R L
inst✝⁶ : Field K
inst✝⁵ : LieAlgebra K L
inst✝⁴ : FiniteDimensional K L
H : LieSubalgebra K L
inst✝³ : H.IsCartanSubalgebra
inst✝² : IsTriangularizable K (↥H) L
inst✝¹ : IsKilling K L
inst✝ : PerfectField K
α : ↥H → K
x : L
hx : x ∈ rootSpace H α
h : ↥H
⊢ ⁅h, x⁆ = α h • x
state_after: R : Type u_1
K : Type u_2
L : Type u_3
inst✝⁹ : CommRing R
inst✝⁸ : LieRing L
inst✝⁷ : LieAlgebra R L
inst✝⁶ : Field K
inst✝⁵ : LieAlgebra K L
inst✝⁴ : FiniteDimensional K L
H : LieSubalgebra K L
inst✝³ : H.IsCartanSubalgebra
inst✝² : IsTriangularizable K (↥H) L
inst✝¹ : IsKilling K L
inst✝ : PerfectField K
α : ↥H → K
x : L
h : ↥H
hx : x ∈ ((ad K L) ↑h).maxGenEigenspace (α h)
⊢ ⁅h, x⁆ = α h • x
tactic: replace hx : x ∈ (ad K L h).maxGenEigenspace (α h) :=
    weightSpace_le_weightSpaceOf L h α hx
state_before: R : Type u_1
K : Type u_2
L : Type u_3
inst✝⁹ : CommRing R
inst✝⁸ : LieRing L
inst✝⁷ : LieAlgebra R L
inst✝⁶ : Field K
inst✝⁵ : LieAlgebra K L
inst✝⁴ : FiniteDimensional K L
H : LieSubalgebra K L
inst✝³ : H.IsCartanSubalgebra
inst✝² : IsTriangularizable K (↥H) L
inst✝¹ : IsKilling K L
inst✝ : PerfectField K
α : ↥H → K
x : L
h : ↥H
hx : x ∈ ((ad K L) ↑h).maxGenEigenspace (α h)
⊢ ⁅h, x⁆ = α h • x
state_after: R : Type u_1
K : Type u_2
L : Type u_3
inst✝⁹ : CommRing R
inst✝⁸ : LieRing L
inst✝⁷ : LieAlgebra R L
inst✝⁶ : Field K
inst✝⁵ : LieAlgebra K L
inst✝⁴ : FiniteDimensional K L
H : LieSubalgebra K L
inst✝³ : H.IsCartanSubalgebra
inst✝² : IsTriangularizable K (↥H) L
inst✝¹ : IsKilling K L
inst✝ : PerfectField K
α : ↥H → K
x : L
h : ↥H
hx : ((ad K L) ↑h) x = α h • x
⊢ ⁅h, x⁆ = α h • x
tactic: rw [(isSemisimple_ad_of_mem_isCartanSubalgebra
    h.property).maxGenEigenspace_eq_eigenspace, Module.End.mem_eigenspace_iff] at hx
state_before: R : Type u_1
K : Type u_2
L : Type u_3
inst✝⁹ : CommRing R
inst✝⁸ : LieRing L
inst✝⁷ : LieAlgebra R L
inst✝⁶ : Field K
inst✝⁵ : LieAlgebra K L
inst✝⁴ : FiniteDimensional K L
H : LieSubalgebra K L
inst✝³ : H.IsCartanSubalgebra
inst✝² : IsTriangularizable K (↥H) L
inst✝¹ : IsKilling K L
inst✝ : PerfectField K
α : ↥H → K
x : L
h : ↥H
hx : ((ad K L) ↑h) x = α h • x
⊢ ⁅h, x⁆ = α h • x
state_after: no goals
tactic: simpa using hx
Theorem: Cardinal.cantor'
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α β : Type u
a b : Cardinal.{u_1}
hb : 1 < b
⊢ a < b ^ a
state_after: α β : Type u
a b : Cardinal.{u_1}
hb : 2 ≤ b
⊢ a < b ^ a
tactic: rw [← succ_le_iff, (by norm_cast : succ (1 : Cardinal) = 2)] at hb
state_before: α β : Type u
a b : Cardinal.{u_1}
hb : 2 ≤ b
⊢ a < b ^ a
state_after: no goals
tactic: exact (cantor a).trans_le (power_le_power_right hb)
Theorem: IntermediateField.normal_iff_forall_map_le
File: Mathlib/FieldTheory/NormalClosure.lean

Proof steps:
state_before: F : Type u_1
K✝¹ : Type u_2
L : Type u_3
inst✝⁵ : Field F
inst✝⁴ : Field K✝¹
inst✝³ : Field L
inst✝² : Algebra F K✝¹
inst✝¹ : Algebra F L
K✝ K' : IntermediateField F L
inst✝ : Normal F L
K : IntermediateField F L
⊢ Normal F ↥K ↔ ∀ (σ : L →ₐ[F] L), map σ K ≤ K
state_after: no goals
tactic: rw [normal_iff_normalClosure_le, normalClosure_def', iSup_le_iff]
Theorem: ZMod.intCast_eq_iff
File: Mathlib/Data/ZMod/Basic.lean

Proof steps:
state_before: m n✝ p : ℕ
n : ℤ
z : ZMod p
inst✝ : NeZero p
⊢ ↑n = z ↔ ∃ k, n = ↑z.val + ↑p * k
state_after: case mp
m n✝ p : ℕ
n : ℤ
z : ZMod p
inst✝ : NeZero p
⊢ ↑n = z → ∃ k, n = ↑z.val + ↑p * k

case mpr
m n✝ p : ℕ
n : ℤ
z : ZMod p
inst✝ : NeZero p
⊢ (∃ k, n = ↑z.val + ↑p * k) → ↑n = z
tactic: constructor
Theorem: deriv2_sqrt_mul_log
File: Mathlib/Analysis/Convex/SpecificFunctions/Deriv.lean

Proof steps:
state_before: x : ℝ
⊢ deriv^[2] (fun x => √x * log x) x = -log x / (4 * √x ^ 3)
state_after: x : ℝ
⊢ deriv (fun x => (2 + log x) / (2 * √x)) x = -log x / (4 * √x ^ 3)
tactic: simp only [Nat.iterate, deriv_sqrt_mul_log']
state_before: x : ℝ
⊢ deriv (fun x => (2 + log x) / (2 * √x)) x = -log x / (4 * √x ^ 3)
state_after: case inl
x : ℝ
hx : x ≤ 0
⊢ deriv (fun x => (2 + log x) / (2 * √x)) x = -log x / (4 * √x ^ 3)

case inr
x : ℝ
hx : 0 < x
⊢ deriv (fun x => (2 + log x) / (2 * √x)) x = -log x / (4 * √x ^ 3)
tactic: rcases le_or_lt x 0 with hx | hx
Theorem: Turing.TM2to1.addBottom_nth_succ_fst
File: Mathlib/Computability/TuringMachine.lean

Proof steps:
state_before: K : Type u_1
inst✝² : DecidableEq K
Γ : K → Type u_2
Λ : Type u_3
inst✝¹ : Inhabited Λ
σ : Type u_4
inst✝ : Inhabited σ
L : ListBlank ((k : K) → Option (Γ k))
n : ℕ
⊢ ((addBottom L).nth (n + 1)).1 = false
state_after: no goals
tactic: rw [ListBlank.nth_succ, addBottom, ListBlank.tail_cons, ListBlank.nth_map]
Theorem: MeasureTheory.Measure.one_le_hausdorffMeasure_zero_of_nonempty
File: Mathlib/MeasureTheory/Measure/Hausdorff.lean

Proof steps:
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝³ : EMetricSpace X
inst✝² : EMetricSpace Y
inst✝¹ : MeasurableSpace X
inst✝ : BorelSpace X
s : Set X
h : s.Nonempty
⊢ 1 ≤ μH[0] s
state_after: case intro
ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝³ : EMetricSpace X
inst✝² : EMetricSpace Y
inst✝¹ : MeasurableSpace X
inst✝ : BorelSpace X
s : Set X
x : X
hx : x ∈ s
⊢ 1 ≤ μH[0] s
tactic: rcases h with ⟨x, hx⟩
state_before: case intro
ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝³ : EMetricSpace X
inst✝² : EMetricSpace Y
inst✝¹ : MeasurableSpace X
inst✝ : BorelSpace X
s : Set X
x : X
hx : x ∈ s
⊢ 1 ≤ μH[0] s
state_after: no goals
tactic: calc
    (1 : ℝ≥0∞) = μH[0] ({x} : Set X) := (hausdorffMeasure_zero_singleton x).symm
    _ ≤ μH[0] s := measure_mono (singleton_subset_iff.2 hx)
Theorem: PNat.gcdA'_coe
File: Mathlib/Data/PNat/Xgcd.lean

Proof steps:
state_before: a b : ℕ+
⊢ ↑(a.gcdA' b) = ↑(a.gcdW b) + a.gcdX b
state_after: a b : ℕ+
⊢ (a.xgcd b).wp + (a.xgcd b).x + 1 = (a.xgcd b).wp + 1 + (a.xgcd b).x
tactic: dsimp [gcdA', gcdX, gcdW, XgcdType.w]
state_before: a b : ℕ+
⊢ (a.xgcd b).wp + (a.xgcd b).x + 1 = (a.xgcd b).wp + 1 + (a.xgcd b).x
state_after: no goals
tactic: rw [add_right_comm]
Theorem: Nat.ModEq.of_div
File: Mathlib/Data/Nat/ModEq.lean

Proof steps:
state_before: m n a b c d : ℕ
h : a / c ≡ b / c [MOD m / c]
ha✝¹ : c ∣ a
ha✝ : c ∣ b
ha : c ∣ m
⊢ a ≡ b [MOD m]
state_after: no goals
tactic: convert h.mul_left' c <;> rwa [Nat.mul_div_cancel']
Theorem: CochainComplex.mappingCone.liftCochain_v_fst_v
File: Mathlib/Algebra/Homology/HomotopyCategory/MappingCone.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝⁴ : Category.{?u.181392, u_1} C
inst✝³ : Category.{?u.181396, u_2} D
inst✝² : Preadditive C
inst✝¹ : Preadditive D
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
K : CochainComplex C ℤ
n m : ℤ
α : Cochain K F m
β : Cochain K G n
h : n + 1 = m
p₁ p₂ p₃ : ℤ
h₁₂ : p₁ + n = p₂
h₂₃ : p₂ + 1 = p₃
⊢ p₁ + m = p₃
state_after: no goals
tactic: omega
state_before: C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : Category.{?u.181396, u_2} D
inst✝² : Preadditive C
inst✝¹ : Preadditive D
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
K : CochainComplex C ℤ
n m : ℤ
α : Cochain K F m
β : Cochain K G n
h : n + 1 = m
p₁ p₂ p₃ : ℤ
h₁₂ : p₁ + n = p₂
h₂₃ : p₂ + 1 = p₃
⊢ (liftCochain φ α β h).v p₁ p₂ h₁₂ ≫ (↑(fst φ)).v p₂ p₃ h₂₃ = α.v p₁ p₃ ⋯
state_after: no goals
tactic: simpa only [Cochain.comp_v _ _ h p₁ p₂ p₃ h₁₂ h₂₃]
    using Cochain.congr_v (liftCochain_fst φ α β h) p₁ p₃ (by omega)
Theorem: MeasurableEmbedding.singularPart_map
File: Mathlib/MeasureTheory/Decomposition/RadonNikodym.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ : Measure α
mβ : MeasurableSpace β
f : α → β
hf : MeasurableEmbedding f
μ ν : Measure α
inst✝¹ : SigmaFinite μ
inst✝ : SigmaFinite ν
⊢ (map f μ).singularPart (map f ν) = map f (μ.singularPart ν)
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ : Measure α
mβ : MeasurableSpace β
f : α → β
hf : MeasurableEmbedding f
μ ν : Measure α
inst✝¹ : SigmaFinite μ
inst✝ : SigmaFinite ν
h_add : map f μ = map f (μ.singularPart ν) + (map f ν).withDensity ((map f μ).rnDeriv (map f ν))
⊢ (map f μ).singularPart (map f ν) = map f (μ.singularPart ν)
tactic: have h_add : μ.map f = (μ.singularPart ν).map f
      + (ν.map f).withDensity ((μ.map f).rnDeriv (ν.map f)) := by
    conv_lhs => rw [μ.haveLebesgueDecomposition_add ν]
    rw [Measure.map_add _ _ hf.measurable, ← hf.map_withDensity_rnDeriv μ ν]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ : Measure α
mβ : MeasurableSpace β
f : α → β
hf : MeasurableEmbedding f
μ ν : Measure α
inst✝¹ : SigmaFinite μ
inst✝ : SigmaFinite ν
h_add : map f μ = map f (μ.singularPart ν) + (map f ν).withDensity ((map f μ).rnDeriv (map f ν))
⊢ (map f μ).singularPart (map f ν) = map f (μ.singularPart ν)
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ : Measure α
mβ : MeasurableSpace β
f : α → β
hf : MeasurableEmbedding f
μ ν : Measure α
inst✝¹ : SigmaFinite μ
inst✝ : SigmaFinite ν
h_add : map f μ = map f (μ.singularPart ν) + (map f ν).withDensity ((map f μ).rnDeriv (map f ν))
⊢ map f (μ.singularPart ν) ⟂ₘ map f ν
tactic: refine (Measure.eq_singularPart (Measure.measurable_rnDeriv _ _) ?_ h_add).symm
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ : Measure α
mβ : MeasurableSpace β
f : α → β
hf : MeasurableEmbedding f
μ ν : Measure α
inst✝¹ : SigmaFinite μ
inst✝ : SigmaFinite ν
h_add : map f μ = map f (μ.singularPart ν) + (map f ν).withDensity ((map f μ).rnDeriv (map f ν))
⊢ map f (μ.singularPart ν) ⟂ₘ map f ν
state_after: no goals
tactic: exact hf.mutuallySingular_map (μ.mutuallySingular_singularPart ν)
Theorem: Nat.primeFactorsList_zero
File: Mathlib/Data/Nat/Factors.lean

Proof steps:
state_before: ⊢ primeFactorsList 0 = []
state_after: no goals
tactic: rw [primeFactorsList]
Theorem: MulLECancellable.mul_le_mul_iff_right
File: Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : LE α
inst✝¹ : Mul α
i : IsSymmOp α α fun x x_1 => x * x_1
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c : α
ha : MulLECancellable a
⊢ b * a ≤ c * a ↔ b ≤ c
state_after: no goals
tactic: rw [i.symm_op b, i.symm_op c, ha.mul_le_mul_iff_left]
Theorem: LinearMap.BilinForm.orthogonal_eq_top_iff
File: Mathlib/LinearAlgebra/BilinearForm/Orthogonal.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝¹¹ : CommSemiring R
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : Module R M
R₁ : Type u_3
M₁ : Type u_4
inst✝⁸ : CommRing R₁
inst✝⁷ : AddCommGroup M₁
inst✝⁶ : Module R₁ M₁
V : Type u_5
K : Type u_6
inst✝⁵ : Field K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
B✝ : BilinForm R M
B₁ : BilinForm R₁ M₁
M₂' : Type u_7
inst✝² : AddCommMonoid M₂'
inst✝¹ : Module R M₂'
inst✝ : FiniteDimensional K V
B : BilinForm K V
W : Submodule K V
b₁ : B.IsRefl
b₂ : (B.restrict W).Nondegenerate
⊢ B.orthogonal W = ⊤ ↔ W = ⊥
state_after: R : Type u_1
M : Type u_2
inst✝¹¹ : CommSemiring R
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : Module R M
R₁ : Type u_3
M₁ : Type u_4
inst✝⁸ : CommRing R₁
inst✝⁷ : AddCommGroup M₁
inst✝⁶ : Module R₁ M₁
V : Type u_5
K : Type u_6
inst✝⁵ : Field K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
B✝ : BilinForm R M
B₁ : BilinForm R₁ M₁
M₂' : Type u_7
inst✝² : AddCommMonoid M₂'
inst✝¹ : Module R M₂'
inst✝ : FiniteDimensional K V
B : BilinForm K V
W : Submodule K V
b₁ : B.IsRefl
b₂ : (B.restrict W).Nondegenerate
h : B.orthogonal W = ⊤
⊢ W = ⊥
tactic: refine ⟨fun h ↦ ?_, fun h ↦ by simp [h]⟩
state_before: R : Type u_1
M : Type u_2
inst✝¹¹ : CommSemiring R
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : Module R M
R₁ : Type u_3
M₁ : Type u_4
inst✝⁸ : CommRing R₁
inst✝⁷ : AddCommGroup M₁
inst✝⁶ : Module R₁ M₁
V : Type u_5
K : Type u_6
inst✝⁵ : Field K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
B✝ : BilinForm R M
B₁ : BilinForm R₁ M₁
M₂' : Type u_7
inst✝² : AddCommMonoid M₂'
inst✝¹ : Module R M₂'
inst✝ : FiniteDimensional K V
B : BilinForm K V
W : Submodule K V
b₁ : B.IsRefl
b₂ : (B.restrict W).Nondegenerate
h : B.orthogonal W = ⊤
⊢ W = ⊥
state_after: R : Type u_1
M : Type u_2
inst✝¹¹ : CommSemiring R
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : Module R M
R₁ : Type u_3
M₁ : Type u_4
inst✝⁸ : CommRing R₁
inst✝⁷ : AddCommGroup M₁
inst✝⁶ : Module R₁ M₁
V : Type u_5
K : Type u_6
inst✝⁵ : Field K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
B✝ : BilinForm R M
B₁ : BilinForm R₁ M₁
M₂' : Type u_7
inst✝² : AddCommMonoid M₂'
inst✝¹ : Module R M₂'
inst✝ : FiniteDimensional K V
B : BilinForm K V
W : Submodule K V
b₁ : B.IsRefl
b₂ : (B.restrict W).Nondegenerate
h : B.orthogonal W = ⊤
this : W ⊓ B.orthogonal W = ⊥
⊢ W = ⊥
tactic: have := (B.isCompl_orthogonal_of_restrict_nondegenerate b₁ b₂).inf_eq_bot
state_before: R : Type u_1
M : Type u_2
inst✝¹¹ : CommSemiring R
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : Module R M
R₁ : Type u_3
M₁ : Type u_4
inst✝⁸ : CommRing R₁
inst✝⁷ : AddCommGroup M₁
inst✝⁶ : Module R₁ M₁
V : Type u_5
K : Type u_6
inst✝⁵ : Field K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
B✝ : BilinForm R M
B₁ : BilinForm R₁ M₁
M₂' : Type u_7
inst✝² : AddCommMonoid M₂'
inst✝¹ : Module R M₂'
inst✝ : FiniteDimensional K V
B : BilinForm K V
W : Submodule K V
b₁ : B.IsRefl
b₂ : (B.restrict W).Nondegenerate
h : B.orthogonal W = ⊤
this : W ⊓ B.orthogonal W = ⊥
⊢ W = ⊥
state_after: no goals
tactic: rwa [h, inf_top_eq] at this
Theorem: Option.none_orElse'
File: Mathlib/Data/Option/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
x : Option α
⊢ (none.orElse fun x_1 => x) = x
state_after: no goals
tactic: cases x <;> rfl
Theorem: Associated.mul_right
File: Mathlib/Algebra/Associated/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoid α
a b : α
h : a ~ᵤ b
c : α
⊢ a * c ~ᵤ b * c
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoid α
a c : α
d : αˣ
⊢ a * c ~ᵤ a * ↑d * c
tactic: obtain ⟨d, rfl⟩ := h
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoid α
a c : α
d : αˣ
⊢ a * c ~ᵤ a * ↑d * c
state_after: no goals
tactic: exact ⟨d, mul_right_comm _ _ _⟩
Theorem: Ordnode.insert'_eq_insertWith
File: Mathlib/Data/Ordmap/Ordset.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Preorder α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
x : α
size✝ : ℕ
l : Ordnode α
y : α
r : Ordnode α
⊢ insert' x (node size✝ l y r) = insertWith id x (node size✝ l y r)
state_after: α : Type u_1
inst✝¹ : Preorder α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
x : α
size✝ : ℕ
l : Ordnode α
y : α
r : Ordnode α
⊢ (match cmpLE x y with
    | Ordering.lt => (insert' x l).balanceL y r
    | Ordering.eq => node size✝ l y r
    | Ordering.gt => l.balanceR y (insert' x r)) =
    match cmpLE x y with
    | Ordering.lt => (insertWith id x l).balanceL y r
    | Ordering.eq => node size✝ l (id y) r
    | Ordering.gt => l.balanceR y (insertWith id x r)
tactic: unfold insert' insertWith
state_before: α : Type u_1
inst✝¹ : Preorder α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
x : α
size✝ : ℕ
l : Ordnode α
y : α
r : Ordnode α
⊢ (match cmpLE x y with
    | Ordering.lt => (insert' x l).balanceL y r
    | Ordering.eq => node size✝ l y r
    | Ordering.gt => l.balanceR y (insert' x r)) =
    match cmpLE x y with
    | Ordering.lt => (insertWith id x l).balanceL y r
    | Ordering.eq => node size✝ l (id y) r
    | Ordering.gt => l.balanceR y (insertWith id x r)
state_after: no goals
tactic: cases cmpLE x y <;> simp [insert'_eq_insertWith]
Theorem: smul_neg
File: Mathlib/Algebra/GroupWithZero/Action/Defs.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
G : Type u_3
A : Type u_4
B : Type u_5
α : Type u_6
β : Type u_7
γ : Type u_8
δ : Type u_9
inst✝² : Monoid M
inst✝¹ : AddGroup A
inst✝ : DistribMulAction M A
r : M
x : A
⊢ r • -x + r • x = 0
state_after: no goals
tactic: rw [← smul_add, neg_add_self, smul_zero]
Theorem: CategoryTheory.Limits.Trident.ofι_π_app
File: Mathlib/CategoryTheory/Limits/Shapes/WideEqualizers.lean

Proof steps:
state_before: J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
f✝ : J → (X ⟶ Y)
inst✝ : Nonempty J
P : C
ι : P ⟶ X
w : ∀ (j₁ j₂ : J), ι ≫ f✝ j₁ = ι ≫ f✝ j₂
i j : WalkingParallelFamily J
f : i ⟶ j
⊢ ((Functor.const (WalkingParallelFamily J)).obj P).map f ≫
      (fun X_1 => WalkingParallelFamily.casesOn X_1 ι (ι ≫ f✝ (Classical.arbitrary J))) j =
    (fun X_1 => WalkingParallelFamily.casesOn X_1 ι (ι ≫ f✝ (Classical.arbitrary J))) i ≫ (parallelFamily f✝).map f
state_after: J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
f✝ : J → (X ⟶ Y)
inst✝ : Nonempty J
P : C
ι : P ⟶ X
w : ∀ (j₁ j₂ : J), ι ≫ f✝ j₁ = ι ≫ f✝ j₂
i j : WalkingParallelFamily J
f : i ⟶ j
⊢ 𝟙 P ≫ WalkingParallelFamily.rec ι (ι ≫ f✝ (Classical.arbitrary J)) j =
    WalkingParallelFamily.rec ι (ι ≫ f✝ (Classical.arbitrary J)) i ≫ (parallelFamily f✝).map f
tactic: dsimp
state_before: J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
f✝ : J → (X ⟶ Y)
inst✝ : Nonempty J
P : C
ι : P ⟶ X
w : ∀ (j₁ j₂ : J), ι ≫ f✝ j₁ = ι ≫ f✝ j₂
i j : WalkingParallelFamily J
f : i ⟶ j
⊢ 𝟙 P ≫ WalkingParallelFamily.rec ι (ι ≫ f✝ (Classical.arbitrary J)) j =
    WalkingParallelFamily.rec ι (ι ≫ f✝ (Classical.arbitrary J)) i ≫ (parallelFamily f✝).map f
state_after: case id
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
inst✝ : Nonempty J
P : C
ι : P ⟶ X
w : ∀ (j₁ j₂ : J), ι ≫ f j₁ = ι ≫ f j₂
i : WalkingParallelFamily J
⊢ 𝟙 P ≫ WalkingParallelFamily.rec ι (ι ≫ f (Classical.arbitrary J)) i =
    WalkingParallelFamily.rec ι (ι ≫ f (Classical.arbitrary J)) i ≫ (parallelFamily f).map (Hom.id i)

case line
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
inst✝ : Nonempty J
P : C
ι : P ⟶ X
w : ∀ (j₁ j₂ : J), ι ≫ f j₁ = ι ≫ f j₂
k : J
⊢ 𝟙 P ≫ WalkingParallelFamily.rec ι (ι ≫ f (Classical.arbitrary J)) one =
    WalkingParallelFamily.rec ι (ι ≫ f (Classical.arbitrary J)) zero ≫ (parallelFamily f).map (line k)
tactic: cases' f with _ k
Theorem: Set.iUnion_nonempty_self
File: Mathlib/Data/Set/Lattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
s : Set α
⊢ ⋃ (_ : s.Nonempty), s = s
state_after: no goals
tactic: rw [iUnion_nonempty_index, biUnion_self]
Theorem: HasLineDerivAt.of_comp
File: Mathlib/Analysis/Calculus/LineDeriv/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
E : Type u_3
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
E' : Type u_4
inst✝¹ : AddCommGroup E'
inst✝ : Module 𝕜 E'
f : E → F
f' : F
x v✝ : E'
L : E' →ₗ[𝕜] E
v : E'
hf : HasLineDerivAt 𝕜 (f ∘ ⇑L) f' x v
⊢ HasLineDerivAt 𝕜 f f' (L x) (L v)
state_after: no goals
tactic: simpa [HasLineDerivAt] using hf
Theorem: Set.einfsep_iUnion_mem_option
File: Mathlib/Topology/MetricSpace/Infsep.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : EDist α
x y : α
s✝ t : Set α
ι : Type u_3
o : Option ι
s : ι → Set α
⊢ (⋃ i ∈ o, s i).einfsep = ⨅ i ∈ o, (s i).einfsep
state_after: no goals
tactic: cases o <;> simp
Theorem: sub_le_sub_iff_left
File: Mathlib/Algebra/Order/Group/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
inst✝³ : Group α
inst✝² : LE α
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
a✝ b c a : α
⊢ a / b ≤ a / c ↔ c ≤ b
state_after: no goals
tactic: rw [div_eq_mul_inv, div_eq_mul_inv, ← mul_le_mul_iff_left a⁻¹, inv_mul_cancel_left,
    inv_mul_cancel_left, inv_le_inv_iff]
Theorem: SetTheory.Game.bddAbove_of_small
File: Mathlib/SetTheory/Game/Basic.lean

Proof steps:
state_before: s : Set Game
inst✝ : Small.{u, u + 1} ↑s
⊢ BddAbove s
state_after: no goals
tactic: simpa using bddAbove_range_of_small (Subtype.val : s → Game.{u})
Theorem: star_nonneg_iff
File: Mathlib/Algebra/Star/Order.lean

Proof steps:
state_before: R : Type u
inst✝³ : NonUnitalSemiring R
inst✝² : PartialOrder R
inst✝¹ : StarRing R
inst✝ : StarOrderedRing R
x : R
⊢ 0 ≤ star x ↔ 0 ≤ x
state_after: no goals
tactic: simpa using star_le_star_iff (x := 0) (y := x)
Theorem: Complex.angle_eq_abs_arg
File: Mathlib/Analysis/Complex/Angle.lean

Proof steps:
state_before: a x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
⊢ angle x y = |(x / y).arg|
state_after: a x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
⊢ ⟪x, y⟫_ℝ / (‖x‖ * ‖y‖) = Real.cos |(x / y).arg|
tactic: refine Real.arccos_eq_of_eq_cos (abs_nonneg _) (abs_arg_le_pi _) ?_
state_before: a x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
⊢ ⟪x, y⟫_ℝ / (‖x‖ * ‖y‖) = Real.cos |(x / y).arg|
state_after: a x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
⊢ ⟪x, y⟫_ℝ / (‖x‖ * ‖y‖) = (x / y).re / abs (x / y)
tactic: rw [Real.cos_abs, Complex.cos_arg (div_ne_zero hx hy)]
state_before: a x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
⊢ ⟪x, y⟫_ℝ / (‖x‖ * ‖y‖) = (x / y).re / abs (x / y)
state_after: a x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
this : abs x ≠ 0
⊢ ⟪x, y⟫_ℝ / (‖x‖ * ‖y‖) = (x / y).re / abs (x / y)
tactic: have := (map_ne_zero Complex.abs).2 hx
state_before: a x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
this : abs x ≠ 0
⊢ ⟪x, y⟫_ℝ / (‖x‖ * ‖y‖) = (x / y).re / abs (x / y)
state_after: a x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
this✝ : abs x ≠ 0
this : abs y ≠ 0
⊢ ⟪x, y⟫_ℝ / (‖x‖ * ‖y‖) = (x / y).re / abs (x / y)
tactic: have := (map_ne_zero Complex.abs).2 hy
state_before: a x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
this✝ : abs x ≠ 0
this : abs y ≠ 0
⊢ ⟪x, y⟫_ℝ / (‖x‖ * ‖y‖) = (x / y).re / abs (x / y)
state_after: a x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
this✝ : abs x ≠ 0
this : abs y ≠ 0
⊢ (x.re * y.re + x.im * y.im) * ((abs y)⁻¹ * (abs x)⁻¹) =
    (x.re * (y.re * (abs y ^ 2)⁻¹) + x.im * (y.im * (abs y ^ 2)⁻¹)) * (abs y * (abs x)⁻¹)
tactic: simp [div_eq_mul_inv, Complex.normSq_eq_norm_sq]
state_before: a x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
this✝ : abs x ≠ 0
this : abs y ≠ 0
⊢ (x.re * y.re + x.im * y.im) * ((abs y)⁻¹ * (abs x)⁻¹) =
    (x.re * (y.re * (abs y ^ 2)⁻¹) + x.im * (y.im * (abs y ^ 2)⁻¹)) * (abs y * (abs x)⁻¹)
state_after: a x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
this✝ : abs x ≠ 0
this : abs y ≠ 0
⊢ (x.re * y.re + x.im * y.im) * (abs y ^ 2 * abs x) = (x.re * y.re + x.im * y.im) * abs y * (abs y * abs x)
tactic: field_simp
state_before: a x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
this✝ : abs x ≠ 0
this : abs y ≠ 0
⊢ (x.re * y.re + x.im * y.im) * (abs y ^ 2 * abs x) = (x.re * y.re + x.im * y.im) * abs y * (abs y * abs x)
state_after: no goals
tactic: ring
Theorem: CategoryTheory.Functor.IsCartesian.ext
File: Mathlib/CategoryTheory/FiberedCategory/Cartesian.lean

Proof steps:
state_before: 𝒮 : Type u₁
𝒳 : Type u₂
inst✝⁵ : Category.{v₁, u₁} 𝒮
inst✝⁴ : Category.{v₂, u₂} 𝒳
p : 𝒳 ⥤ 𝒮
R S : 𝒮
a b : 𝒳
f : R ⟶ S
φ✝ : a ⟶ b
inst✝³ : p.IsCartesian f φ✝
φ : a ⟶ b
inst✝² : p.IsCartesian f φ
a' : 𝒳
ψ ψ' : a' ⟶ a
inst✝¹ : p.IsHomLift (𝟙 R) ψ
inst✝ : p.IsHomLift (𝟙 R) ψ'
h : ψ ≫ φ = ψ' ≫ φ
⊢ ψ = ψ'
state_after: no goals
tactic: rw [map_uniq p f φ (ψ ≫ φ) ψ rfl, map_uniq p f φ (ψ ≫ φ) ψ' h.symm]