ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: IsCompact.measure_eq_biInf_integral_hasCompactSupport
File: Mathlib/MeasureTheory/Measure/Haar/Unique.lean

Proof steps:
state_before: X : Type u_1
inst✝⁶ : TopologicalSpace X
inst✝⁵ : MeasurableSpace X
inst✝⁴ : BorelSpace X
k : Set X
hk : IsCompact k
μ : Measure X
inst✝³ : IsFiniteMeasureOnCompacts μ
inst✝² : μ.InnerRegularCompactLTTop
inst✝¹ : LocallyCompactSpace X
inst✝ : RegularSpace X
⊢ μ k =
    ⨅ f,
      ⨅ (_ : Continuous f),
        ⨅ (_ : HasCompactSupport f), ⨅ (_ : EqOn f 1 k), ⨅ (_ : 0 ≤ f), ENNReal.ofReal (∫ (x : X), f x ∂μ)
state_after: case a
X : Type u_1
inst✝⁶ : TopologicalSpace X
inst✝⁵ : MeasurableSpace X
inst✝⁴ : BorelSpace X
k : Set X
hk : IsCompact k
μ : Measure X
inst✝³ : IsFiniteMeasureOnCompacts μ
inst✝² : μ.InnerRegularCompactLTTop
inst✝¹ : LocallyCompactSpace X
inst✝ : RegularSpace X
⊢ μ k ≤
    ⨅ f,
      ⨅ (_ : Continuous f),
        ⨅ (_ : HasCompactSupport f), ⨅ (_ : EqOn f 1 k), ⨅ (_ : 0 ≤ f), ENNReal.ofReal (∫ (x : X), f x ∂μ)

case a
X : Type u_1
inst✝⁶ : TopologicalSpace X
inst✝⁵ : MeasurableSpace X
inst✝⁴ : BorelSpace X
k : Set X
hk : IsCompact k
μ : Measure X
inst✝³ : IsFiniteMeasureOnCompacts μ
inst✝² : μ.InnerRegularCompactLTTop
inst✝¹ : LocallyCompactSpace X
inst✝ : RegularSpace X
⊢ ⨅ f,
      ⨅ (_ : Continuous f),
        ⨅ (_ : HasCompactSupport f), ⨅ (_ : EqOn f 1 k), ⨅ (_ : 0 ≤ f), ENNReal.ofReal (∫ (x : X), f x ∂μ) ≤
    μ k
tactic: apply le_antisymm
Theorem: NormedAddGroupHom.opNorm_zero_iff
File: Mathlib/Analysis/Normed/Group/Hom.lean

Proof steps:
state_before: V : Type u_1
V₁✝ : Type u_2
V₂✝ : Type u_3
V₃ : Type u_4
inst✝⁵ : SeminormedAddCommGroup V
inst✝⁴ : SeminormedAddCommGroup V₁✝
inst✝³ : SeminormedAddCommGroup V₂✝
inst✝² : SeminormedAddCommGroup V₃
f✝ g : NormedAddGroupHom V₁✝ V₂✝
V₁ : Type u_5
V₂ : Type u_6
inst✝¹ : NormedAddCommGroup V₁
inst✝ : NormedAddCommGroup V₂
f : NormedAddGroupHom V₁ V₂
hn : ‖f‖ = 0
x : V₁
⊢ ‖f‖ * ‖x‖ = 0
state_after: no goals
tactic: rw [hn, zero_mul]
state_before: V : Type u_1
V₁✝ : Type u_2
V₂✝ : Type u_3
V₃ : Type u_4
inst✝⁵ : SeminormedAddCommGroup V
inst✝⁴ : SeminormedAddCommGroup V₁✝
inst✝³ : SeminormedAddCommGroup V₂✝
inst✝² : SeminormedAddCommGroup V₃
f✝ g : NormedAddGroupHom V₁✝ V₂✝
V₁ : Type u_5
V₂ : Type u_6
inst✝¹ : NormedAddCommGroup V₁
inst✝ : NormedAddCommGroup V₂
f : NormedAddGroupHom V₁ V₂
hf : f = 0
⊢ ‖f‖ = 0
state_after: no goals
tactic: rw [hf, opNorm_zero]
Theorem: Equiv.pow_addRight
File: Mathlib/GroupTheory/Perm/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝ : AddGroup α
a b : α
n : ℕ
⊢ Equiv.addRight a ^ n = Equiv.addRight (n • a)
state_after: case H
α : Type u
β : Type v
inst✝ : AddGroup α
a b : α
n : ℕ
x✝ : α
⊢ (Equiv.addRight a ^ n) x✝ = (Equiv.addRight (n • a)) x✝
tactic: ext
state_before: case H
α : Type u
β : Type v
inst✝ : AddGroup α
a b : α
n : ℕ
x✝ : α
⊢ (Equiv.addRight a ^ n) x✝ = (Equiv.addRight (n • a)) x✝
state_after: no goals
tactic: simp [Perm.coe_pow]
Theorem: mul_add_mul_le_mul_add_mul
File: Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
β : Type u_1
inst✝⁵ : Semiring α
inst✝⁴ : PartialOrder α
a b c d : α
inst✝³ : ExistsAddOfLE α
inst✝² : MulPosMono α
inst✝¹ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝ : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
hab : a ≤ b
hcd : c ≤ d
⊢ a * d + b * c ≤ a * c + b * d
state_after: case intro
α : Type u
β : Type u_1
inst✝⁵ : Semiring α
inst✝⁴ : PartialOrder α
a c d : α
inst✝³ : ExistsAddOfLE α
inst✝² : MulPosMono α
inst✝¹ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝ : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
hcd : c ≤ d
b : α
hab : a ≤ a + b
⊢ a * d + (a + b) * c ≤ a * c + (a + b) * d
tactic: obtain ⟨b, rfl⟩ := exists_add_of_le hab
state_before: case intro
α : Type u
β : Type u_1
inst✝⁵ : Semiring α
inst✝⁴ : PartialOrder α
a c d : α
inst✝³ : ExistsAddOfLE α
inst✝² : MulPosMono α
inst✝¹ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝ : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
hcd : c ≤ d
b : α
hab : a ≤ a + b
⊢ a * d + (a + b) * c ≤ a * c + (a + b) * d
state_after: case intro.intro
α : Type u
β : Type u_1
inst✝⁵ : Semiring α
inst✝⁴ : PartialOrder α
a c : α
inst✝³ : ExistsAddOfLE α
inst✝² : MulPosMono α
inst✝¹ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝ : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
b : α
hab : a ≤ a + b
d : α
hcd : c ≤ c + d
⊢ a * (c + d) + (a + b) * c ≤ a * c + (a + b) * (c + d)
tactic: obtain ⟨d, rfl⟩ := exists_add_of_le hcd
state_before: case intro.intro
α : Type u
β : Type u_1
inst✝⁵ : Semiring α
inst✝⁴ : PartialOrder α
a c : α
inst✝³ : ExistsAddOfLE α
inst✝² : MulPosMono α
inst✝¹ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝ : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
b : α
hab : a ≤ a + b
d : α
hcd : c ≤ c + d
⊢ a * (c + d) + (a + b) * c ≤ a * c + (a + b) * (c + d)
state_after: case intro.intro
α : Type u
β : Type u_1
inst✝⁵ : Semiring α
inst✝⁴ : PartialOrder α
a c : α
inst✝³ : ExistsAddOfLE α
inst✝² : MulPosMono α
inst✝¹ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝ : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
b : α
hab : a ≤ a + b
d : α
hcd : c ≤ c + d
⊢ a * c + (a + b) * c + a * d ≤ a * c + (a + b) * c + (a + b) * d
tactic: rw [mul_add, add_right_comm, mul_add, ← add_assoc]
state_before: case intro.intro
α : Type u
β : Type u_1
inst✝⁵ : Semiring α
inst✝⁴ : PartialOrder α
a c : α
inst✝³ : ExistsAddOfLE α
inst✝² : MulPosMono α
inst✝¹ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝ : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
b : α
hab : a ≤ a + b
d : α
hcd : c ≤ c + d
⊢ a * c + (a + b) * c + a * d ≤ a * c + (a + b) * c + (a + b) * d
state_after: no goals
tactic: exact add_le_add_left (mul_le_mul_of_nonneg_right hab <| (le_add_iff_nonneg_right _).1 hcd) _
Theorem: FractionalIdeal.count_mul'
File: Mathlib/RingTheory/DedekindDomain/Factorization.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
I I' : FractionalIdeal R⁰ K
⊢ count K v (I * I') = if I ≠ 0 ∧ I' ≠ 0 then count K v I + count K v I' else 0
state_after: case pos
R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
I I' : FractionalIdeal R⁰ K
h : I ≠ 0 ∧ I' ≠ 0
⊢ count K v (I * I') = count K v I + count K v I'

case neg
R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
I I' : FractionalIdeal R⁰ K
h : ¬(I ≠ 0 ∧ I' ≠ 0)
⊢ count K v (I * I') = 0
tactic: split_ifs with h
Theorem: FirstOrder.Sequence₂.lift_mk
File: Mathlib/ModelTheory/Basic.lean

Proof steps:
state_before: a₀ a₁ a₂ : Type u
i : ℕ
⊢ lift.{v, u} #(Sequence₂ a₀ a₁ a₂ i) = #(Sequence₂ (ULift.{v, u} a₀) (ULift.{v, u} a₁) (ULift.{v, u} a₂) i)
state_after: no goals
tactic: rcases i with (_ | _ | _ | i) <;>
    simp only [Sequence₂, mk_uLift, Nat.succ_ne_zero, IsEmpty.forall_iff, Nat.succ.injEq,
      add_eq_zero, OfNat.ofNat_ne_zero, and_false, one_ne_zero, mk_eq_zero, lift_zero]
Theorem: isLittleO_pow_pow_of_abs_lt_left
File: Mathlib/Analysis/SpecificLimits/Normed.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
r₁ r₂ : ℝ
h : |r₁| < |r₂|
⊢ (fun n => r₁ ^ n) =o[atTop] fun n => r₂ ^ n
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
r₁ r₂ : ℝ
h : |r₁| < |r₂|
⊢ (fun x => ‖r₁ ^ x‖) =o[atTop] fun x => ‖r₂ ^ x‖
tactic: refine (IsLittleO.of_norm_left ?_).of_norm_right
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
r₁ r₂ : ℝ
h : |r₁| < |r₂|
⊢ (fun x => ‖r₁ ^ x‖) =o[atTop] fun x => ‖r₂ ^ x‖
state_after: no goals
tactic: exact (isLittleO_pow_pow_of_lt_left (abs_nonneg r₁) h).congr (pow_abs r₁) (pow_abs r₂)
Theorem: finsuppTensorFinsupp'_symm_single_eq_single_one_tmul
File: Mathlib/LinearAlgebra/DirectSum/Finsupp.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
M : Type u_3
N : Type u_4
ι : Type u_5
κ : Type u_6
inst✝⁸ : CommSemiring R
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
inst✝³ : Semiring S
inst✝² : Algebra R S
inst✝¹ : Module S M
inst✝ : IsScalarTower R S M
i : ι × κ
r : R
⊢ (finsuppTensorFinsupp' R ι κ).symm (Finsupp.single i r) = Finsupp.single i.1 1 ⊗ₜ[R] Finsupp.single i.2 r
state_after: R : Type u_1
S : Type u_2
M : Type u_3
N : Type u_4
ι : Type u_5
κ : Type u_6
inst✝⁸ : CommSemiring R
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
inst✝³ : Semiring S
inst✝² : Algebra R S
inst✝¹ : Module S M
inst✝ : IsScalarTower R S M
i : ι × κ
r : R
⊢ (finsuppTensorFinsupp' R ι κ).symm (Finsupp.single i (1 * r)) = Finsupp.single i.1 1 ⊗ₜ[R] Finsupp.single i.2 r
tactic: nth_rw 1 [← one_mul r]
state_before: R : Type u_1
S : Type u_2
M : Type u_3
N : Type u_4
ι : Type u_5
κ : Type u_6
inst✝⁸ : CommSemiring R
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
inst✝³ : Semiring S
inst✝² : Algebra R S
inst✝¹ : Module S M
inst✝ : IsScalarTower R S M
i : ι × κ
r : R
⊢ (finsuppTensorFinsupp' R ι κ).symm (Finsupp.single i (1 * r)) = Finsupp.single i.1 1 ⊗ₜ[R] Finsupp.single i.2 r
state_after: no goals
tactic: exact finsuppTensorFinsupp'_symm_single_mul R ι κ i _ _
Theorem: Nat.add_pred_div_lt
File: Mathlib/Data/Nat/Log.lean

Proof steps:
state_before: b n : ℕ
hb : 1 < b
hn : 2 ≤ n
⊢ (n + b - 1) / b < n
state_after: b n : ℕ
hb : 1 < b
hn : 2 ≤ n
⊢ n + b ≤ n * b
tactic: rw [div_lt_iff_lt_mul (by omega), ← succ_le_iff, ← pred_eq_sub_one,
    succ_pred_eq_of_pos (by omega)]
state_before: b n : ℕ
hb : 1 < b
hn : 2 ≤ n
⊢ n + b ≤ n * b
state_after: no goals
tactic: exact Nat.add_le_mul hn hb
Theorem: Sum.Lex.Ico_inl_inl
File: Mathlib/Data/Sum/Interval.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : Preorder α
inst✝⁴ : Preorder β
inst✝³ : OrderTop α
inst✝² : OrderBot β
inst✝¹ : LocallyFiniteOrder α
inst✝ : LocallyFiniteOrder β
a a₁ a₂ : α
b b₁ b₂ : β
⊢ Ico (inlₗ a₁) (inlₗ a₂) = map (Embedding.inl.trans toLex.toEmbedding) (Ico a₁ a₂)
state_after: α : Type u_1
β : Type u_2
inst✝⁵ : Preorder α
inst✝⁴ : Preorder β
inst✝³ : OrderTop α
inst✝² : OrderBot β
inst✝¹ : LocallyFiniteOrder α
inst✝ : LocallyFiniteOrder β
a a₁ a₂ : α
b b₁ b₂ : β
⊢ Ico (inlₗ a₁) (inlₗ a₂) = map toLex.toEmbedding (map Embedding.inl (Ico a₁ a₂))
tactic: rw [← Finset.map_map]
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : Preorder α
inst✝⁴ : Preorder β
inst✝³ : OrderTop α
inst✝² : OrderBot β
inst✝¹ : LocallyFiniteOrder α
inst✝ : LocallyFiniteOrder β
a a₁ a₂ : α
b b₁ b₂ : β
⊢ Ico (inlₗ a₁) (inlₗ a₂) = map toLex.toEmbedding (map Embedding.inl (Ico a₁ a₂))
state_after: no goals
tactic: rfl
Theorem: Int.fract_div_natCast_eq_div_natCast_mod
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : LinearOrderedRing α
inst✝² : FloorRing α
z : ℤ
a : α
k : Type u_4
inst✝¹ : LinearOrderedField k
inst✝ : FloorRing k
b : k
m n : ℕ
⊢ fract (↑m / ↑n) = ↑(m % n) / ↑n
state_after: case inl
F : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : LinearOrderedRing α
inst✝² : FloorRing α
z : ℤ
a : α
k : Type u_4
inst✝¹ : LinearOrderedField k
inst✝ : FloorRing k
b : k
m : ℕ
⊢ fract (↑m / ↑0) = ↑(m % 0) / ↑0

case inr
F : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : LinearOrderedRing α
inst✝² : FloorRing α
z : ℤ
a : α
k : Type u_4
inst✝¹ : LinearOrderedField k
inst✝ : FloorRing k
b : k
m n : ℕ
hn : n > 0
⊢ fract (↑m / ↑n) = ↑(m % n) / ↑n
tactic: rcases n.eq_zero_or_pos with (rfl | hn)
state_before: case inr
F : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : LinearOrderedRing α
inst✝² : FloorRing α
z : ℤ
a : α
k : Type u_4
inst✝¹ : LinearOrderedField k
inst✝ : FloorRing k
b : k
m n : ℕ
hn : n > 0
⊢ fract (↑m / ↑n) = ↑(m % n) / ↑n
state_after: case inr
F : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : LinearOrderedRing α
inst✝² : FloorRing α
z : ℤ
a : α
k : Type u_4
inst✝¹ : LinearOrderedField k
inst✝ : FloorRing k
b : k
m n : ℕ
hn : n > 0
hn' : 0 < ↑n
⊢ fract (↑m / ↑n) = ↑(m % n) / ↑n
tactic: have hn' : 0 < (n : k) := by
    norm_cast
state_before: case inr
F : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : LinearOrderedRing α
inst✝² : FloorRing α
z : ℤ
a : α
k : Type u_4
inst✝¹ : LinearOrderedField k
inst✝ : FloorRing k
b : k
m n : ℕ
hn : n > 0
hn' : 0 < ↑n
⊢ fract (↑m / ↑n) = ↑(m % n) / ↑n
state_after: case inr.refine_1
F : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : LinearOrderedRing α
inst✝² : FloorRing α
z : ℤ
a : α
k : Type u_4
inst✝¹ : LinearOrderedField k
inst✝ : FloorRing k
b : k
m n : ℕ
hn : n > 0
hn' : 0 < ↑n
⊢ 0 ≤ ↑(m % n) / ↑n

case inr.refine_2
F : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : LinearOrderedRing α
inst✝² : FloorRing α
z : ℤ
a : α
k : Type u_4
inst✝¹ : LinearOrderedField k
inst✝ : FloorRing k
b : k
m n : ℕ
hn : n > 0
hn' : 0 < ↑n
⊢ ↑(m % n) / ↑n < 1

case inr.refine_3
F : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : LinearOrderedRing α
inst✝² : FloorRing α
z : ℤ
a : α
k : Type u_4
inst✝¹ : LinearOrderedField k
inst✝ : FloorRing k
b : k
m n : ℕ
hn : n > 0
hn' : 0 < ↑n
⊢ ↑m / ↑n - ↑(m % n) / ↑n = ↑(↑m / ↑n)
tactic: refine fract_eq_iff.mpr ⟨?_, ?_, m / n, ?_⟩
Theorem: Cardinal.ofENat_eq_one
File: Mathlib/SetTheory/Cardinal/ENat.lean

Proof steps:
state_before: m : ℕ∞
⊢ ↑m = 1 ↔ m = 1
state_after: no goals
tactic: norm_cast
Theorem: List.maximum_eq_coe_iff
File: Mathlib/Data/List/MinMax.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
l : List α
a m : α
⊢ l.maximum = ↑m ↔ m ∈ l ∧ ∀ (a : α), a ∈ l → a ≤ m
state_after: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
l : List α
a m : α
⊢ (m ∈ l ∧ (∀ (a : α), a ∈ l → id a ≤ id m) ∧ ∀ (a : α), a ∈ l → id m ≤ id a → indexOf m l ≤ indexOf a l) ↔
    m ∈ l ∧ ∀ (a : α), a ∈ l → a ≤ m
tactic: rw [maximum, ← WithBot.some_eq_coe, argmax_eq_some_iff]
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
l : List α
a m : α
⊢ (m ∈ l ∧ (∀ (a : α), a ∈ l → id a ≤ id m) ∧ ∀ (a : α), a ∈ l → id m ≤ id a → indexOf m l ≤ indexOf a l) ↔
    m ∈ l ∧ ∀ (a : α), a ∈ l → a ≤ m
state_after: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
l : List α
a m : α
⊢ m ∈ l → (∀ (a : α), a ∈ l → a ≤ m) → ∀ (a : α), a ∈ l → m ≤ a → indexOf m l ≤ indexOf a l
tactic: simp only [id_eq, and_congr_right_iff, and_iff_left_iff_imp]
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
l : List α
a m : α
⊢ m ∈ l → (∀ (a : α), a ∈ l → a ≤ m) → ∀ (a : α), a ∈ l → m ≤ a → indexOf m l ≤ indexOf a l
state_after: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
l : List α
a✝¹ m : α
a✝ : m ∈ l
h : ∀ (a : α), a ∈ l → a ≤ m
a : α
hal : a ∈ l
hma : m ≤ a
⊢ indexOf m l ≤ indexOf a l
tactic: intro _ h a hal hma
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
l : List α
a✝¹ m : α
a✝ : m ∈ l
h : ∀ (a : α), a ∈ l → a ≤ m
a : α
hal : a ∈ l
hma : m ≤ a
⊢ indexOf m l ≤ indexOf a l
state_after: no goals
tactic: rw [_root_.le_antisymm hma (h a hal)]
Theorem: Multiset.revzip_powersetAux
File: Mathlib/Data/Multiset/Powerset.lean

Proof steps:
state_before: α : Type u_1
l : List α
x : Multiset α × Multiset α
h : x ∈ (powersetAux l).revzip
⊢ x.1 + x.2 = ↑l
state_after: α : Type u_1
l : List α
x : Multiset α × Multiset α
h : ∃ a ∈ l.sublists.revzip, Prod.map ofList ofList a = x
⊢ x.1 + x.2 = ↑l
tactic: rw [revzip, powersetAux_eq_map_coe, ← map_reverse, zip_map, ← revzip, List.mem_map] at h
state_before: α : Type u_1
l : List α
x : Multiset α × Multiset α
h : ∃ a ∈ l.sublists.revzip, Prod.map ofList ofList a = x
⊢ x.1 + x.2 = ↑l
state_after: α : Type u_1
l : List α
x : Multiset α × Multiset α
h : ∃ a b, (a, b) ∈ l.sublists.revzip ∧ (↑a, ↑b) = x
⊢ x.1 + x.2 = ↑l
tactic: simp only [Prod.map_apply, Prod.exists] at h
state_before: α : Type u_1
l : List α
x : Multiset α × Multiset α
h : ∃ a b, (a, b) ∈ l.sublists.revzip ∧ (↑a, ↑b) = x
⊢ x.1 + x.2 = ↑l
state_after: case intro.intro.intro.refl
α : Type u_1
l l₁ l₂ : List α
h : (l₁, l₂) ∈ l.sublists.revzip
⊢ (↑l₁, ↑l₂).1 + (↑l₁, ↑l₂).2 = ↑l
tactic: rcases h with ⟨l₁, l₂, h, rfl, rfl⟩
state_before: case intro.intro.intro.refl
α : Type u_1
l l₁ l₂ : List α
h : (l₁, l₂) ∈ l.sublists.revzip
⊢ (↑l₁, ↑l₂).1 + (↑l₁, ↑l₂).2 = ↑l
state_after: no goals
tactic: exact Quot.sound (revzip_sublists _ _ _ h)
Theorem: Batteries.BinomialHeap.Imp.HeapNode.WF.toHeap.go
File: .lake/packages/batteries/Batteries/Data/BinomialHeap/Basic.lean

Proof steps:
state_before: α : Type u_1
le : α → α → Bool
a✝ : α
n✝ : Nat
s✝ : HeapNode α
h✝ : WF le a✝ s✝ n✝
res : Heap α
a : α
c s : HeapNode α
n : Nat
left✝ : ∀ [inst : TotalBLE le], le a✝ a = true
h : WF le a c n
h' : WF le a✝ s n
hr : Heap.WF le (node a c s).rank res
⊢ WF le a c ((node a c s).rank - 1)
state_after: α : Type u_1
le : α → α → Bool
a✝ : α
n✝ : Nat
s✝ : HeapNode α
h✝ : WF le a✝ s✝ n✝
res : Heap α
a : α
c s : HeapNode α
n : Nat
left✝ : ∀ [inst : TotalBLE le], le a✝ a = true
h : WF le a c s.rank
h' : WF le a✝ s n
hr : Heap.WF le (node a c s).rank res
⊢ WF le a c ((node a c s).rank - 1)
tactic: rw [← h'.rank_eq] at h
state_before: α : Type u_1
le : α → α → Bool
a✝ : α
n✝ : Nat
s✝ : HeapNode α
h✝ : WF le a✝ s✝ n✝
res : Heap α
a : α
c s : HeapNode α
n : Nat
left✝ : ∀ [inst : TotalBLE le], le a✝ a = true
h : WF le a c s.rank
h' : WF le a✝ s n
hr : Heap.WF le (node a c s).rank res
⊢ WF le a c ((node a c s).rank - 1)
state_after: no goals
tactic: exact h
Theorem: CategoryTheory.CategoryOfElements.CreatesLimitsAux.liftedCone_π_app_coe
File: Mathlib/CategoryTheory/Limits/Elements.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
A : C ⥤ Type w
I : Type u₁
inst✝³ : Category.{v₁, u₁} I
inst✝² : Small.{w, u₁} I
F : I ⥤ A.Elements
inst✝¹ : HasLimitsOfShape I C
inst✝ : PreservesLimitsOfShape I A
i : I
⊢ A.map (limit.π (F ⋙ π A) i) (((Functor.const I).obj ⟨limit (F ⋙ π A), liftedConeElement F⟩).obj i).snd = (F.obj i).snd
state_after: no goals
tactic: simp
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
A : C ⥤ Type w
I : Type u₁
inst✝³ : Category.{v₁, u₁} I
inst✝² : Small.{w, u₁} I
F : I ⥤ A.Elements
inst✝¹ : HasLimitsOfShape I C
inst✝ : PreservesLimitsOfShape I A
i i' : I
f : i ⟶ i'
⊢ ((Functor.const I).obj ⟨limit (F ⋙ π A), liftedConeElement F⟩).map f ≫ (fun i => ⟨limit.π (F ⋙ π A) i, ⋯⟩) i' =
    (fun i => ⟨limit.π (F ⋙ π A) i, ⋯⟩) i ≫ F.map f
state_after: case w
C : Type u
inst✝⁴ : Category.{v, u} C
A : C ⥤ Type w
I : Type u₁
inst✝³ : Category.{v₁, u₁} I
inst✝² : Small.{w, u₁} I
F : I ⥤ A.Elements
inst✝¹ : HasLimitsOfShape I C
inst✝ : PreservesLimitsOfShape I A
i i' : I
f : i ⟶ i'
⊢ ↑(((Functor.const I).obj ⟨limit (F ⋙ π A), liftedConeElement F⟩).map f ≫ (fun i => ⟨limit.π (F ⋙ π A) i, ⋯⟩) i') =
    ↑((fun i => ⟨limit.π (F ⋙ π A) i, ⋯⟩) i ≫ F.map f)
tactic: ext
state_before: case w
C : Type u
inst✝⁴ : Category.{v, u} C
A : C ⥤ Type w
I : Type u₁
inst✝³ : Category.{v₁, u₁} I
inst✝² : Small.{w, u₁} I
F : I ⥤ A.Elements
inst✝¹ : HasLimitsOfShape I C
inst✝ : PreservesLimitsOfShape I A
i i' : I
f : i ⟶ i'
⊢ ↑(((Functor.const I).obj ⟨limit (F ⋙ π A), liftedConeElement F⟩).map f ≫ (fun i => ⟨limit.π (F ⋙ π A) i, ⋯⟩) i') =
    ↑((fun i => ⟨limit.π (F ⋙ π A) i, ⋯⟩) i ≫ F.map f)
state_after: no goals
tactic: simpa using (limit.w _ _).symm
Theorem: InnerProductGeometry.angle_neg_right
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean

Proof steps:
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
⊢ angle x (-y) = π - angle x y
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
⊢ arccos (⟪x, -y⟫_ℝ / (‖x‖ * ‖-y‖)) = π - arccos (⟪x, y⟫_ℝ / (‖x‖ * ‖y‖))
tactic: unfold angle
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
⊢ arccos (⟪x, -y⟫_ℝ / (‖x‖ * ‖-y‖)) = π - arccos (⟪x, y⟫_ℝ / (‖x‖ * ‖y‖))
state_after: no goals
tactic: rw [← Real.arccos_neg, norm_neg, inner_neg_right, neg_div]
Theorem: _private.Mathlib.SetTheory.Game.PGame.0.SetTheory.PGame.add_le_add_right'
File: Mathlib/SetTheory/Game/PGame.lean

Proof steps:
state_before: xl✝ xr✝ : Type u
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
h : mk xl xr xL xR ≤ mk yl yr yL yR
⊢ mk xl xr xL xR + mk zl zr zL zR ≤ mk yl yr yL yR + mk zl zr zL zR
state_after: case refine_1.inl
xl✝ xr✝ : Type u
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
h : mk xl xr xL xR ≤ mk yl yr yL yR
i : xl
⊢ (∃ i', (mk xl xr xL xR + mk zl zr zL zR).moveLeft (Sum.inl i) ≤ (mk yl yr yL yR + mk zl zr zL zR).moveLeft i') ∨
    ∃ j, ((mk xl xr xL xR + mk zl zr zL zR).moveLeft (Sum.inl i)).moveRight j ≤ mk yl yr yL yR + mk zl zr zL zR

case refine_1.inr
xl✝ xr✝ : Type u
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
h : mk xl xr xL xR ≤ mk yl yr yL yR
i : zl
⊢ (∃ i', (mk xl xr xL xR + mk zl zr zL zR).moveLeft (Sum.inr i) ≤ (mk yl yr yL yR + mk zl zr zL zR).moveLeft i') ∨
    ∃ j, ((mk xl xr xL xR + mk zl zr zL zR).moveLeft (Sum.inr i)).moveRight j ≤ mk yl yr yL yR + mk zl zr zL zR

case refine_2.inl
xl✝ xr✝ : Type u
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
h : mk xl xr xL xR ≤ mk yl yr yL yR
i : yr
⊢ (∃ i_1, mk xl xr xL xR + mk zl zr zL zR ≤ ((mk yl yr yL yR + mk zl zr zL zR).moveRight (Sum.inl i)).moveLeft i_1) ∨
    ∃ j', (mk xl xr xL xR + mk zl zr zL zR).moveRight j' ≤ (mk yl yr yL yR + mk zl zr zL zR).moveRight (Sum.inl i)

case refine_2.inr
xl✝ xr✝ : Type u
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
h : mk xl xr xL xR ≤ mk yl yr yL yR
i : zr
⊢ (∃ i_1, mk xl xr xL xR + mk zl zr zL zR ≤ ((mk yl yr yL yR + mk zl zr zL zR).moveRight (Sum.inr i)).moveLeft i_1) ∨
    ∃ j', (mk xl xr xL xR + mk zl zr zL zR).moveRight j' ≤ (mk yl yr yL yR + mk zl zr zL zR).moveRight (Sum.inr i)
tactic: refine le_def.2 ⟨fun i => ?_, fun i => ?_⟩ <;> cases' i with i i
Theorem: Finset.Iic_add_Iio_subset
File: Mathlib/Data/Finset/Pointwise/Interval.lean

Proof steps:
state_before: α : Type u_1
inst✝⁵ : Mul α
inst✝⁴ : PartialOrder α
inst✝³ : DecidableEq α
inst✝² : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝¹ : CovariantClass α α (Function.swap HMul.hMul) LT.lt
inst✝ : LocallyFiniteOrderBot α
a b : α
⊢ ↑(Iic a * Iio b) ⊆ ↑(Iio (a * b))
state_after: no goals
tactic: simpa using Set.Iic_mul_Iio_subset' _ _
Theorem: List.rdrop_add
File: Mathlib/Data/List/DropRight.lean

Proof steps:
state_before: α : Type u_1
p : α → Bool
l : List α
n i j : ℕ
⊢ (l.rdrop i).rdrop j = l.rdrop (i + j)
state_after: no goals
tactic: simp_rw [rdrop_eq_reverse_drop_reverse, reverse_reverse, drop_drop, Nat.add_comm]
Theorem: CochainComplex.mappingCone.triangleRotateShortComplex_X₃
File: Mathlib/Algebra/Homology/HomotopyCategory/DegreewiseSplit.lean

Proof steps:
state_before: C : Type u_1
inst✝² : Category.{?u.282061, u_1} C
inst✝¹ : Preadditive C
S : ShortComplex (CochainComplex C ℤ)
σ : (n : ℤ) → (S.map (eval C (ComplexShape.up ℤ) n)).Splitting
inst✝ : HasBinaryBiproducts C
K L : CochainComplex C ℤ
φ : K ⟶ L
⊢ (triangle φ).rotate.mor₁ ≫ (triangle φ).rotate.mor₂ = 0
state_after: no goals
tactic: simp