ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: MultilinearMap.map_sub
File: Mathlib/LinearAlgebra/Multilinear/Basic.lean

Proof steps:
state_before: R : Type uR
S : Type uS
ι : Type uι
n : ℕ
M : Fin n.succ → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝⁵ : Semiring R
inst✝⁴ : (i : ι) → AddCommGroup (M₁ i)
inst✝³ : AddCommGroup M₂
inst✝² : (i : ι) → Module R (M₁ i)
inst✝¹ : Module R M₂
f : MultilinearMap R M₁ M₂
inst✝ : DecidableEq ι
m : (i : ι) → M₁ i
i : ι
x y : M₁ i
⊢ f (update m i (x - y)) = f (update m i x) - f (update m i y)
state_after: no goals
tactic: rw [sub_eq_add_neg, sub_eq_add_neg, MultilinearMap.map_add, map_neg]
Theorem: List.extractP_eq_find?_eraseP
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α : Type u_1
p : α → Bool
l : List α
acc : Array α
h : l = acc.data ++ []
⊢ extractP.go p l [] acc = (find? p [], acc.data ++ eraseP p [])
state_after: no goals
tactic: simp [extractP.go, find?, eraseP, h]
state_before: α : Type u_1
p : α → Bool
l : List α
acc : Array α
x : α
xs : List α
⊢ l = acc.data ++ x :: xs → extractP.go p l (x :: xs) acc = (find? p (x :: xs), acc.data ++ eraseP p (x :: xs))
state_after: α : Type u_1
p : α → Bool
l : List α
acc : Array α
x : α
xs : List α
⊢ l = acc.data ++ x :: xs →
    (bif p x then (some x, acc.data ++ xs) else extractP.go p l xs (acc.push x)) =
      (match p x with
        | true => some x
        | false => find? p xs,
        acc.data ++ bif p x then xs else x :: eraseP p xs)
tactic: simp [extractP.go, find?, eraseP]
state_before: α : Type u_1
p : α → Bool
l : List α
acc : Array α
x : α
xs : List α
⊢ l = acc.data ++ x :: xs →
    (bif p x then (some x, acc.data ++ xs) else extractP.go p l xs (acc.push x)) =
      (match p x with
        | true => some x
        | false => find? p xs,
        acc.data ++ bif p x then xs else x :: eraseP p xs)
state_after: case false
α : Type u_1
p : α → Bool
l : List α
acc : Array α
x : α
xs : List α
⊢ l = acc.data ++ x :: xs → extractP.go p l xs (acc.push x) = (find? p xs, acc.data ++ x :: eraseP p xs)
tactic: cases p x <;> simp
state_before: α : Type u_1
p : α → Bool
l : List α
⊢ extractP p l = (find? p l, eraseP p l)
state_after: no goals
tactic: exact go #[] _ rfl
Theorem: PartENat.add_left_cancel_iff
File: Mathlib/Data/Nat/PartENat.lean

Proof steps:
state_before: a b c : PartENat
ha : a ≠ ⊤
⊢ a + b = a + c ↔ b = c
state_after: no goals
tactic: rw [add_comm a, add_comm a, PartENat.add_right_cancel_iff ha]
Theorem: nilpotencyClass_eq_zero_of_subsingleton
File: Mathlib/RingTheory/Nilpotent/Defs.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
x y : R
inst✝² : Zero R
inst✝¹ : Pow R ℕ
inst✝ : Subsingleton R
⊢ nilpotencyClass x = 0
state_after: R : Type u_1
S : Type u_2
x y : R
inst✝² : Zero R
inst✝¹ : Pow R ℕ
inst✝ : Subsingleton R
s : Set ℕ := {k | x ^ k = 0}
⊢ nilpotencyClass x = 0
tactic: let s : Set ℕ := {k | x ^ k = 0}
state_before: R : Type u_1
S : Type u_2
x y : R
inst✝² : Zero R
inst✝¹ : Pow R ℕ
inst✝ : Subsingleton R
s : Set ℕ := {k | x ^ k = 0}
⊢ nilpotencyClass x = 0
state_after: R : Type u_1
S : Type u_2
x y : R
inst✝² : Zero R
inst✝¹ : Pow R ℕ
inst✝ : Subsingleton R
s : Set ℕ := {k | x ^ k = 0}
⊢ s = univ
tactic: suffices s = univ by change sInf _ = 0; simp [s] at this; simp [this]
state_before: R : Type u_1
S : Type u_2
x y : R
inst✝² : Zero R
inst✝¹ : Pow R ℕ
inst✝ : Subsingleton R
s : Set ℕ := {k | x ^ k = 0}
⊢ s = univ
state_after: no goals
tactic: exact eq_univ_iff_forall.mpr fun k ↦ Subsingleton.elim _ _
Theorem: MeasureTheory.lintegral_withDensity_le_lintegral_mul
File: Mathlib/MeasureTheory/Measure/WithDensity.lean

Proof steps:
state_before: α : Type u_1
m0 : MeasurableSpace α
μ✝ μ : Measure α
f : α → ℝ≥0∞
f_meas : Measurable f
g : α → ℝ≥0∞
⊢ ∫⁻ (a : α), g a ∂μ.withDensity f ≤ ∫⁻ (a : α), (f * g) a ∂μ
state_after: α : Type u_1
m0 : MeasurableSpace α
μ✝ μ : Measure α
f : α → ℝ≥0∞
f_meas : Measurable f
g : α → ℝ≥0∞
⊢ ⨆ g_1, ⨆ (_ : Measurable g_1), ⨆ (_ : g_1 ≤ g), ∫⁻ (a : α), g_1 a ∂μ.withDensity f ≤
    ⨆ g_1, ⨆ (_ : Measurable g_1), ⨆ (_ : g_1 ≤ f * g), ∫⁻ (a : α), g_1 a ∂μ
tactic: rw [← iSup_lintegral_measurable_le_eq_lintegral, ← iSup_lintegral_measurable_le_eq_lintegral]
state_before: α : Type u_1
m0 : MeasurableSpace α
μ✝ μ : Measure α
f : α → ℝ≥0∞
f_meas : Measurable f
g : α → ℝ≥0∞
⊢ ⨆ g_1, ⨆ (_ : Measurable g_1), ⨆ (_ : g_1 ≤ g), ∫⁻ (a : α), g_1 a ∂μ.withDensity f ≤
    ⨆ g_1, ⨆ (_ : Measurable g_1), ⨆ (_ : g_1 ≤ f * g), ∫⁻ (a : α), g_1 a ∂μ
state_after: α : Type u_1
m0 : MeasurableSpace α
μ✝ μ : Measure α
f : α → ℝ≥0∞
f_meas : Measurable f
g i : α → ℝ≥0∞
i_meas : Measurable i
hi : i ≤ g
⊢ ∫⁻ (a : α), i a ∂μ.withDensity f ≤ ⨆ g_1, ⨆ (_ : Measurable g_1), ⨆ (_ : g_1 ≤ f * g), ∫⁻ (a : α), g_1 a ∂μ
tactic: refine iSup₂_le fun i i_meas => iSup_le fun hi => ?_
state_before: α : Type u_1
m0 : MeasurableSpace α
μ✝ μ : Measure α
f : α → ℝ≥0∞
f_meas : Measurable f
g i : α → ℝ≥0∞
i_meas : Measurable i
hi : i ≤ g
⊢ ∫⁻ (a : α), i a ∂μ.withDensity f ≤ ⨆ g_1, ⨆ (_ : Measurable g_1), ⨆ (_ : g_1 ≤ f * g), ∫⁻ (a : α), g_1 a ∂μ
state_after: α : Type u_1
m0 : MeasurableSpace α
μ✝ μ : Measure α
f : α → ℝ≥0∞
f_meas : Measurable f
g i : α → ℝ≥0∞
i_meas : Measurable i
hi : i ≤ g
A : f * i ≤ f * g
⊢ ∫⁻ (a : α), i a ∂μ.withDensity f ≤ ⨆ g_1, ⨆ (_ : Measurable g_1), ⨆ (_ : g_1 ≤ f * g), ∫⁻ (a : α), g_1 a ∂μ
tactic: have A : f * i ≤ f * g := fun x => mul_le_mul_left' (hi x) _
state_before: α : Type u_1
m0 : MeasurableSpace α
μ✝ μ : Measure α
f : α → ℝ≥0∞
f_meas : Measurable f
g i : α → ℝ≥0∞
i_meas : Measurable i
hi : i ≤ g
A : f * i ≤ f * g
⊢ ∫⁻ (a : α), i a ∂μ.withDensity f ≤ ⨆ g_1, ⨆ (_ : Measurable g_1), ⨆ (_ : g_1 ≤ f * g), ∫⁻ (a : α), g_1 a ∂μ
state_after: α : Type u_1
m0 : MeasurableSpace α
μ✝ μ : Measure α
f : α → ℝ≥0∞
f_meas : Measurable f
g i : α → ℝ≥0∞
i_meas : Measurable i
hi : i ≤ g
A : f * i ≤ f * g
⊢ ∫⁻ (a : α), i a ∂μ.withDensity f ≤ ⨆ (_ : f * i ≤ f * g), ∫⁻ (a : α), (f * i) a ∂μ
tactic: refine le_iSup₂_of_le (f * i) (f_meas.mul i_meas) ?_
state_before: α : Type u_1
m0 : MeasurableSpace α
μ✝ μ : Measure α
f : α → ℝ≥0∞
f_meas : Measurable f
g i : α → ℝ≥0∞
i_meas : Measurable i
hi : i ≤ g
A : f * i ≤ f * g
⊢ ∫⁻ (a : α), i a ∂μ.withDensity f ≤ ⨆ (_ : f * i ≤ f * g), ∫⁻ (a : α), (f * i) a ∂μ
state_after: no goals
tactic: exact le_iSup_of_le A (le_of_eq (lintegral_withDensity_eq_lintegral_mul _ f_meas i_meas))
Theorem: EReal.inv_inv
File: Mathlib/Data/Real/EReal.lean

Proof steps:
state_before: a : EReal
h : a ≠ ⊥
h' : a ≠ ⊤
⊢ a⁻¹⁻¹ = a
state_after: no goals
tactic: rw [← coe_toReal h' h, ← coe_inv a.toReal, ← coe_inv a.toReal⁻¹, _root_.inv_inv a.toReal]
Theorem: Commute.multiset_sum_right
File: Mathlib/Algebra/BigOperators/Ring/Multiset.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : NonUnitalNonAssocSemiring α
s : Multiset α
a : α
h : ∀ b ∈ s, Commute a b
⊢ Commute a s.sum
state_after: case h
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : NonUnitalNonAssocSemiring α
s : Multiset α
a : α
a✝ : List α
h : ∀ b ∈ ⟦a✝⟧, Commute a b
⊢ Commute a (sum ⟦a✝⟧)
tactic: induction s using Quotient.inductionOn
state_before: case h
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : NonUnitalNonAssocSemiring α
s : Multiset α
a : α
a✝ : List α
h : ∀ b ∈ ⟦a✝⟧, Commute a b
⊢ Commute a (sum ⟦a✝⟧)
state_after: case h
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : NonUnitalNonAssocSemiring α
s : Multiset α
a : α
a✝ : List α
h : ∀ b ∈ ⟦a✝⟧, Commute a b
⊢ Commute a a✝.sum
tactic: rw [quot_mk_to_coe, sum_coe]
state_before: case h
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : NonUnitalNonAssocSemiring α
s : Multiset α
a : α
a✝ : List α
h : ∀ b ∈ ⟦a✝⟧, Commute a b
⊢ Commute a a✝.sum
state_after: no goals
tactic: exact Commute.list_sum_right _ _ h
Theorem: neg_mem_connectedComponent_zero
File: Mathlib/Topology/Algebra/Group/Basic.lean

Proof steps:
state_before: G✝ : Type w
H : Type x
α : Type u
β : Type v
inst✝⁶ : TopologicalSpace G✝
inst✝⁵ : Group G✝
inst✝⁴ : TopologicalGroup G✝
inst✝³ : TopologicalSpace α
f : α → G✝
s : Set α
x : α
G : Type u_1
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
g : G
hg : g ∈ connectedComponent 1
⊢ g⁻¹ ∈ connectedComponent 1
state_after: G✝ : Type w
H : Type x
α : Type u
β : Type v
inst✝⁶ : TopologicalSpace G✝
inst✝⁵ : Group G✝
inst✝⁴ : TopologicalGroup G✝
inst✝³ : TopologicalSpace α
f : α → G✝
s : Set α
x : α
G : Type u_1
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
g : G
hg : g ∈ connectedComponent 1
⊢ g⁻¹ ∈ connectedComponent 1⁻¹
tactic: rw [← inv_one]
state_before: G✝ : Type w
H : Type x
α : Type u
β : Type v
inst✝⁶ : TopologicalSpace G✝
inst✝⁵ : Group G✝
inst✝⁴ : TopologicalGroup G✝
inst✝³ : TopologicalSpace α
f : α → G✝
s : Set α
x : α
G : Type u_1
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
g : G
hg : g ∈ connectedComponent 1
⊢ g⁻¹ ∈ connectedComponent 1⁻¹
state_after: no goals
tactic: exact
    Continuous.image_connectedComponent_subset continuous_inv _
      ((Set.mem_image _ _ _).mp ⟨g, hg, rfl⟩)
Theorem: Grp.SurjectiveOfEpiAuxs.τ_symm_apply_infinity
File: Mathlib/Algebra/Category/Grp/EpiMono.lean

Proof steps:
state_before: A B : Grp
f : A ⟶ B
⊢ (Equiv.symm τ) ∞ = fromCoset ⟨↑(MonoidHom.range f), ⋯⟩
state_after: no goals
tactic: rw [tau, Equiv.symm_swap, Equiv.swap_apply_right]
Theorem: CategoryTheory.Abelian.mono_of_epi_of_mono_of_mono
File: Mathlib/CategoryTheory/Abelian/DiagramLemmas/Four.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
R₁ R₂ : ComposableArrows C 3
φ : R₁ ⟶ R₂
hR₁ : R₁.Exact
hR₂ : R₂.Exact
h₀ : Epi (app' φ 0 ⋯)
h₁ : Mono (app' φ 1 ⋯)
h₃ : Mono (app' φ 3 ⋯)
⊢ R₁.map' 0 2 ⋯ ⋯ = 0
state_after: no goals
tactic: simpa only [R₁.map'_comp 0 1 2] using hR₁.toIsComplex.zero 0
Theorem: Nat.Prime.dvd_choose_add
File: Mathlib/Data/Nat/Choose/Dvd.lean

Proof steps:
state_before: p a b k : ℕ
hp : Prime p
hap : a < p
hbp : b < p
h : p ≤ a + b
⊢ p ∣ (a + b).choose a
state_after: p a b k : ℕ
hp : Prime p
hap : a < p
hbp : b < p
h : p ≤ a + b
h₁ : p ∣ (a + b)!
⊢ p ∣ (a + b).choose a
tactic: have h₁ : p ∣ (a + b)! := hp.dvd_factorial.2 h
state_before: p a b k : ℕ
hp : Prime p
hap : a < p
hbp : b < p
h : p ≤ a + b
h₁ : p ∣ (a + b)!
⊢ p ∣ (a + b).choose a
state_after: p a b k : ℕ
hp : Prime p
hap : a < p
hbp : b < p
h : p ≤ a + b
h₁ : (p ∣ (a + b).choose a ∨ p ≤ a) ∨ p ≤ b
⊢ p ∣ (a + b).choose a
tactic: rw [← add_choose_mul_factorial_mul_factorial, ← choose_symm_add, hp.dvd_mul, hp.dvd_mul,
    hp.dvd_factorial, hp.dvd_factorial] at h₁
state_before: p a b k : ℕ
hp : Prime p
hap : a < p
hbp : b < p
h : p ≤ a + b
h₁ : (p ∣ (a + b).choose a ∨ p ≤ a) ∨ p ≤ b
⊢ p ∣ (a + b).choose a
state_after: no goals
tactic: exact (h₁.resolve_right hbp.not_le).resolve_right hap.not_le
Theorem: eq_of_le_of_inf_le_of_le_sup
File: Mathlib/Order/ModularLattice.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x y z : α
hxy : x ≤ y
hinf : y ⊓ z ≤ x
hsup : y ≤ x ⊔ z
⊢ x = y
state_after: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x y z : α
hxy : x ≤ y
hinf : y ⊓ z ≤ x
hsup : y ≤ x ⊔ z
⊢ y ≤ x
tactic: refine hxy.antisymm ?_
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x y z : α
hxy : x ≤ y
hinf : y ⊓ z ≤ x
hsup : y ≤ x ⊔ z
⊢ y ≤ x
state_after: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x y z : α
hxy : x ≤ y
hinf : y ⊓ z ≤ x
hsup : x ⊔ z ⊓ y = y
⊢ y ≤ x
tactic: rw [← inf_eq_right, sup_inf_assoc_of_le _ hxy] at hsup
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x y z : α
hxy : x ≤ y
hinf : y ⊓ z ≤ x
hsup : x ⊔ z ⊓ y = y
⊢ y ≤ x
state_after: no goals
tactic: rwa [← hsup, sup_le_iff, and_iff_right rfl.le, inf_comm]
Theorem: Nat.add_modEq_left
File: Mathlib/Data/Nat/ModEq.lean

Proof steps:
state_before: m n a b c d : ℕ
⊢ n + a ≡ a [MOD n]
state_after: no goals
tactic: rw [ModEq, add_mod_left]
Theorem: lineMap_slope_lineMap_slope_lineMap
File: Mathlib/LinearAlgebra/AffineSpace/Slope.lean

Proof steps:
state_before: k : Type u_1
E : Type u_2
PE : Type u_3
inst✝³ : Field k
inst✝² : AddCommGroup E
inst✝¹ : Module k E
inst✝ : AddTorsor E PE
f : k → PE
a b r : k
⊢ (lineMap (slope f ((lineMap a b) r) b) (slope f a ((lineMap a b) r))) r = slope f a b
state_after: case inl
k : Type u_1
E : Type u_2
PE : Type u_3
inst✝³ : Field k
inst✝² : AddCommGroup E
inst✝¹ : Module k E
inst✝ : AddTorsor E PE
f : k → PE
a r : k
⊢ (lineMap (slope f ((lineMap a a) r) a) (slope f a ((lineMap a a) r))) r = slope f a a

case inr
k : Type u_1
E : Type u_2
PE : Type u_3
inst✝³ : Field k
inst✝² : AddCommGroup E
inst✝¹ : Module k E
inst✝ : AddTorsor E PE
f : k → PE
a b r : k
hab : a ≠ b
⊢ (lineMap (slope f ((lineMap a b) r) b) (slope f a ((lineMap a b) r))) r = slope f a b
tactic: obtain rfl | hab : a = b ∨ a ≠ b := Classical.em _
state_before: case inr
k : Type u_1
E : Type u_2
PE : Type u_3
inst✝³ : Field k
inst✝² : AddCommGroup E
inst✝¹ : Module k E
inst✝ : AddTorsor E PE
f : k → PE
a b r : k
hab : a ≠ b
⊢ (lineMap (slope f ((lineMap a b) r) b) (slope f a ((lineMap a b) r))) r = slope f a b
state_after: case inr
k : Type u_1
E : Type u_2
PE : Type u_3
inst✝³ : Field k
inst✝² : AddCommGroup E
inst✝¹ : Module k E
inst✝ : AddTorsor E PE
f : k → PE
a b r : k
hab : a ≠ b
⊢ (lineMap (slope f b ((lineMap a b) r)) (slope f ((lineMap a b) r) a)) r = slope f b a
tactic: rw [slope_comm _ a, slope_comm _ a, slope_comm _ _ b]
state_before: case inr
k : Type u_1
E : Type u_2
PE : Type u_3
inst✝³ : Field k
inst✝² : AddCommGroup E
inst✝¹ : Module k E
inst✝ : AddTorsor E PE
f : k → PE
a b r : k
hab : a ≠ b
⊢ (lineMap (slope f b ((lineMap a b) r)) (slope f ((lineMap a b) r) a)) r = slope f b a
state_after: case h.e'_2.h.e'_6
k : Type u_1
E : Type u_2
PE : Type u_3
inst✝³ : Field k
inst✝² : AddCommGroup E
inst✝¹ : Module k E
inst✝ : AddTorsor E PE
f : k → PE
a b r : k
hab : a ≠ b
⊢ r = (a - (lineMap a b) r) / (a - b)
tactic: convert lineMap_slope_slope_sub_div_sub f b (lineMap a b r) a hab.symm using 2
state_before: case h.e'_2.h.e'_6
k : Type u_1
E : Type u_2
PE : Type u_3
inst✝³ : Field k
inst✝² : AddCommGroup E
inst✝¹ : Module k E
inst✝ : AddTorsor E PE
f : k → PE
a b r : k
hab : a ≠ b
⊢ r = (a - (lineMap a b) r) / (a - b)
state_after: no goals
tactic: rw [lineMap_apply_ring, eq_div_iff (sub_ne_zero.2 hab), sub_mul, one_mul, mul_sub, ← sub_sub,
    sub_sub_cancel]
Theorem: ProbabilityTheory.IdentDistrib.lintegral_eq
File: Mathlib/Probability/IdentDistrib.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
μ : Measure α
ν : Measure β
f✝ : α → γ
g✝ : β → γ
f : α → ℝ≥0∞
g : β → ℝ≥0∞
h : IdentDistrib f g μ ν
⊢ ∫⁻ (x : α), f x ∂μ = ∫⁻ (x : β), g x ∂ν
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
μ : Measure α
ν : Measure β
f✝ : α → γ
g✝ : β → γ
f : α → ℝ≥0∞
g : β → ℝ≥0∞
h : IdentDistrib f g μ ν
⊢ ∫⁻ (x : α), id (f x) ∂μ = ∫⁻ (x : β), id (g x) ∂ν
tactic: change ∫⁻ x, id (f x) ∂μ = ∫⁻ x, id (g x) ∂ν
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
μ : Measure α
ν : Measure β
f✝ : α → γ
g✝ : β → γ
f : α → ℝ≥0∞
g : β → ℝ≥0∞
h : IdentDistrib f g μ ν
⊢ ∫⁻ (x : α), id (f x) ∂μ = ∫⁻ (x : β), id (g x) ∂ν
state_after: no goals
tactic: rw [← lintegral_map' aemeasurable_id h.aemeasurable_fst, ←
    lintegral_map' aemeasurable_id h.aemeasurable_snd, h.map_eq]
Theorem: Filter.antitone_seq_of_seq
File: Mathlib/Order/Filter/Bases.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Sort u_5
s : ℕ → Set α
⊢ ∃ t, Antitone t ∧ ⨅ i, 𝓟 (s i) = ⨅ i, 𝓟 (t i)
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Sort u_5
s : ℕ → Set α
⊢ (Antitone fun n => ⋂ m, ⋂ (_ : m ≤ n), s m) ∧ ⨅ i, 𝓟 (s i) = ⨅ i, 𝓟 (⋂ m, ⋂ (_ : m ≤ i), s m)
tactic: use fun n => ⋂ m ≤ n, s m
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Sort u_5
s : ℕ → Set α
⊢ (Antitone fun n => ⋂ m, ⋂ (_ : m ≤ n), s m) ∧ ⨅ i, 𝓟 (s i) = ⨅ i, 𝓟 (⋂ m, ⋂ (_ : m ≤ i), s m)
state_after: case h.left
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Sort u_5
s : ℕ → Set α
⊢ Antitone fun n => ⋂ m, ⋂ (_ : m ≤ n), s m

case h.right
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Sort u_5
s : ℕ → Set α
⊢ ⨅ i, 𝓟 (s i) = ⨅ i, 𝓟 (⋂ m, ⋂ (_ : m ≤ i), s m)
tactic: constructor
state_before: case h.right
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Sort u_5
s : ℕ → Set α
⊢ ⨅ i, 𝓟 (s i) = ⨅ i, 𝓟 (⋂ m, ⋂ (_ : m ≤ i), s m)
state_after: case h.right.a
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Sort u_5
s : ℕ → Set α
i : ℕ
⊢ ⨅ i, 𝓟 (s i) ≤ 𝓟 (⋂ m, ⋂ (_ : m ≤ i), s m)

case h.right.a
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Sort u_5
s : ℕ → Set α
i : ℕ
⊢ ⨅ i, 𝓟 (⋂ m, ⋂ (_ : m ≤ i), s m) ≤ 𝓟 (s i)
tactic: apply le_antisymm <;> rw [le_iInf_iff] <;> intro i
Theorem: abs_eq_neg_self
File: Mathlib/Algebra/Order/Group/Abs.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a b c d : α
⊢ |a| = -a ↔ a ≤ 0
state_after: no goals
tactic: rw [abs_eq_max_neg, max_eq_right_iff, le_neg_self_iff]
Theorem: IsUpperSet.mul_left
File: Mathlib/Algebra/Order/UpperLower.lean

Proof steps:
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
s t : Set α
a : α
ht : IsUpperSet t
⊢ IsUpperSet (s * t)
state_after: α : Type u_1
inst✝ : OrderedCommGroup α
s t : Set α
a : α
ht : IsUpperSet t
⊢ IsUpperSet (⋃ a ∈ s, a • t)
tactic: rw [← smul_eq_mul, ← Set.iUnion_smul_set]
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
s t : Set α
a : α
ht : IsUpperSet t
⊢ IsUpperSet (⋃ a ∈ s, a • t)
state_after: no goals
tactic: exact isUpperSet_iUnion₂ fun x _ ↦ ht.smul
Theorem: Set.image2_def
File: Mathlib/Data/Set/Functor.lean

Proof steps:
state_before: α✝ β✝ : Type u
s✝ : Set α✝
f✝ : α✝ → Set β✝
g : Set (α✝ → β✝)
α β γ : Type u
f : α → β → γ
s : Set α
t : Set β
⊢ image2 f s t = Seq.seq (f <$> s) fun x => t
state_after: case h
α✝ β✝ : Type u
s✝ : Set α✝
f✝ : α✝ → Set β✝
g : Set (α✝ → β✝)
α β γ : Type u
f : α → β → γ
s : Set α
t : Set β
x✝ : γ
⊢ x✝ ∈ image2 f s t ↔ x✝ ∈ Seq.seq (f <$> s) fun x => t
tactic: ext
state_before: case h
α✝ β✝ : Type u
s✝ : Set α✝
f✝ : α✝ → Set β✝
g : Set (α✝ → β✝)
α β γ : Type u
f : α → β → γ
s : Set α
t : Set β
x✝ : γ
⊢ x✝ ∈ image2 f s t ↔ x✝ ∈ Seq.seq (f <$> s) fun x => t
state_after: no goals
tactic: simp
Theorem: Real.logb_rpow
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

Proof steps:
state_before: b x y : ℝ
b_pos : 0 < b
b_ne_one : b ≠ 1
⊢ logb b (b ^ x) = x
state_after: b x y : ℝ
b_pos : 0 < b
b_ne_one : b ≠ 1
⊢ log b ≠ 0
tactic: rw [logb, div_eq_iff, log_rpow b_pos]
state_before: b x y : ℝ
b_pos : 0 < b
b_ne_one : b ≠ 1
⊢ log b ≠ 0
state_after: no goals
tactic: exact log_b_ne_zero b_pos b_ne_one
Theorem: NNReal.geom_mean_le_arith_mean2_weighted
File: Mathlib/Analysis/MeanInequalities.lean

Proof steps:
state_before: ι : Type u
s : Finset ι
w₁ w₂ p₁ p₂ : ℝ≥0
⊢ w₁ + w₂ = 1 → p₁ ^ ↑w₁ * p₂ ^ ↑w₂ ≤ w₁ * p₁ + w₂ * p₂
state_after: no goals
tactic: simpa only [Fin.prod_univ_succ, Fin.sum_univ_succ, Finset.prod_empty, Finset.sum_empty,
    Finset.univ_eq_empty, Fin.cons_succ, Fin.cons_zero, add_zero, mul_one] using
    geom_mean_le_arith_mean_weighted univ ![w₁, w₂] ![p₁, p₂]
Theorem: Stream'.append_append_stream
File: Mathlib/Data/Stream/Init.lean

Proof steps:
state_before: α : Type u
β : Type v
δ : Type w
a : α
l₁ l₂ : List α
s : Stream' α
⊢ a :: l₁ ++ l₂ ++ₛ s = a :: l₁ ++ₛ (l₂ ++ₛ s)
state_after: no goals
tactic: rw [List.cons_append, cons_append_stream, cons_append_stream, append_append_stream l₁]
Theorem: finsum_pos'
File: Mathlib/Algebra/BigOperators/Finprod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M✝ : Type u_5
N : Type u_6
inst✝² : CommMonoid M✝
inst✝¹ : CommMonoid N
f✝ g : α → M✝
a b : α
s t : Set α
M : Type u_7
inst✝ : OrderedCancelCommMonoid M
f : ι → M
h : ∀ (i : ι), 1 ≤ f i
h' : ∃ i, 1 < f i
hf : (mulSupport f).Finite
⊢ 1 < ∏ᶠ (i : ι), f i
state_after: case intro
α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M✝ : Type u_5
N : Type u_6
inst✝² : CommMonoid M✝
inst✝¹ : CommMonoid N
f✝ g : α → M✝
a b : α
s t : Set α
M : Type u_7
inst✝ : OrderedCancelCommMonoid M
f : ι → M
h : ∀ (i : ι), 1 ≤ f i
hf : (mulSupport f).Finite
i : ι
hi : 1 < f i
⊢ 1 < ∏ᶠ (i : ι), f i
tactic: rcases h' with ⟨i, hi⟩
state_before: case intro
α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M✝ : Type u_5
N : Type u_6
inst✝² : CommMonoid M✝
inst✝¹ : CommMonoid N
f✝ g : α → M✝
a b : α
s t : Set α
M : Type u_7
inst✝ : OrderedCancelCommMonoid M
f : ι → M
h : ∀ (i : ι), 1 ≤ f i
hf : (mulSupport f).Finite
i : ι
hi : 1 < f i
⊢ 1 < ∏ᶠ (i : ι), f i
state_after: case intro
α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M✝ : Type u_5
N : Type u_6
inst✝² : CommMonoid M✝
inst✝¹ : CommMonoid N
f✝ g : α → M✝
a b : α
s t : Set α
M : Type u_7
inst✝ : OrderedCancelCommMonoid M
f : ι → M
h : ∀ (i : ι), 1 ≤ f i
hf : (mulSupport f).Finite
i : ι
hi : 1 < f i
⊢ 1 < ∏ i ∈ hf.toFinset, f i
tactic: rw [finprod_eq_prod _ hf]
state_before: case intro
α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M✝ : Type u_5
N : Type u_6
inst✝² : CommMonoid M✝
inst✝¹ : CommMonoid N
f✝ g : α → M✝
a b : α
s t : Set α
M : Type u_7
inst✝ : OrderedCancelCommMonoid M
f : ι → M
h : ∀ (i : ι), 1 ≤ f i
hf : (mulSupport f).Finite
i : ι
hi : 1 < f i
⊢ 1 < ∏ i ∈ hf.toFinset, f i
state_after: case intro
α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M✝ : Type u_5
N : Type u_6
inst✝² : CommMonoid M✝
inst✝¹ : CommMonoid N
f✝ g : α → M✝
a b : α
s t : Set α
M : Type u_7
inst✝ : OrderedCancelCommMonoid M
f : ι → M
h : ∀ (i : ι), 1 ≤ f i
hf : (mulSupport f).Finite
i : ι
hi : 1 < f i
⊢ i ∈ hf.toFinset
tactic: refine Finset.one_lt_prod' (fun i _ ↦ h i) ⟨i, ?_, hi⟩
state_before: case intro
α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M✝ : Type u_5
N : Type u_6
inst✝² : CommMonoid M✝
inst✝¹ : CommMonoid N
f✝ g : α → M✝
a b : α
s t : Set α
M : Type u_7
inst✝ : OrderedCancelCommMonoid M
f : ι → M
h : ∀ (i : ι), 1 ≤ f i
hf : (mulSupport f).Finite
i : ι
hi : 1 < f i
⊢ i ∈ hf.toFinset
state_after: no goals
tactic: simpa only [Finite.mem_toFinset, mem_mulSupport] using ne_of_gt hi
Theorem: Ring.mul_inverse_cancel_left
File: Mathlib/Algebra/GroupWithZero/Units/Basic.lean

Proof steps:
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : MonoidWithZero M₀
x y : M₀
h : IsUnit x
⊢ x * (inverse x * y) = y
state_after: no goals
tactic: rw [← mul_assoc, mul_inverse_cancel x h, one_mul]
Theorem: hnot_sdiff
File: Mathlib/Order/Heyting/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : CoheytingAlgebra α
a✝ b c a : α
⊢ ￢a \ a = ￢a
state_after: no goals
tactic: rw [← top_sdiff', sdiff_sdiff, sup_idem]