ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: isProperMap_iff_isClosedMap_and_tendsto_cofinite
File: Mathlib/Topology/Maps/Proper/Basic.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
W : Type u_4
ι : Type u_5
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
inst✝¹ : TopologicalSpace W
f : X → Y
g : Y → Z
inst✝ : T1Space Y
⊢ IsProperMap f ↔ Continuous f ∧ IsClosedMap f ∧ Tendsto f (cocompact X) cofinite
state_after: X : Type u_1
Y : Type u_2
Z : Type u_3
W : Type u_4
ι : Type u_5
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
inst✝¹ : TopologicalSpace W
f : X → Y
g : Y → Z
inst✝ : T1Space Y
⊢ (Continuous f ∧ IsClosedMap f ∧ ∀ (y : Y), IsCompact (f ⁻¹' {y})) ↔
    Continuous f ∧ IsClosedMap f ∧ ∀ (x : Y), (f ⁻¹' {x})ᶜ ∈ cocompact X
tactic: simp_rw [isProperMap_iff_isClosedMap_and_compact_fibers, Tendsto,
    le_cofinite_iff_compl_singleton_mem, mem_map, preimage_compl]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
W : Type u_4
ι : Type u_5
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
inst✝¹ : TopologicalSpace W
f : X → Y
g : Y → Z
inst✝ : T1Space Y
⊢ (Continuous f ∧ IsClosedMap f ∧ ∀ (y : Y), IsCompact (f ⁻¹' {y})) ↔
    Continuous f ∧ IsClosedMap f ∧ ∀ (x : Y), (f ⁻¹' {x})ᶜ ∈ cocompact X
state_after: X : Type u_1
Y : Type u_2
Z : Type u_3
W : Type u_4
ι : Type u_5
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
inst✝¹ : TopologicalSpace W
f : X → Y
g : Y → Z
inst✝ : T1Space Y
f_cont : Continuous f
x✝ : IsClosedMap f
H : ∀ (x : Y), (f ⁻¹' {x})ᶜ ∈ cocompact X
y : Y
⊢ IsCompact (f ⁻¹' {y})
tactic: refine and_congr_right fun f_cont ↦ and_congr_right fun _ ↦
    ⟨fun H y ↦ (H y).compl_mem_cocompact, fun H y ↦ ?_⟩
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
W : Type u_4
ι : Type u_5
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
inst✝¹ : TopologicalSpace W
f : X → Y
g : Y → Z
inst✝ : T1Space Y
f_cont : Continuous f
x✝ : IsClosedMap f
H : ∀ (x : Y), (f ⁻¹' {x})ᶜ ∈ cocompact X
y : Y
⊢ IsCompact (f ⁻¹' {y})
state_after: case intro.intro
X : Type u_1
Y : Type u_2
Z : Type u_3
W : Type u_4
ι : Type u_5
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
inst✝¹ : TopologicalSpace W
f : X → Y
g : Y → Z
inst✝ : T1Space Y
f_cont : Continuous f
x✝ : IsClosedMap f
H : ∀ (x : Y), (f ⁻¹' {x})ᶜ ∈ cocompact X
y : Y
K : Set X
hK : IsCompact K
hKy : Kᶜ ⊆ (f ⁻¹' {y})ᶜ
⊢ IsCompact (f ⁻¹' {y})
tactic: rcases mem_cocompact.mp (H y) with ⟨K, hK, hKy⟩
state_before: case intro.intro
X : Type u_1
Y : Type u_2
Z : Type u_3
W : Type u_4
ι : Type u_5
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
inst✝¹ : TopologicalSpace W
f : X → Y
g : Y → Z
inst✝ : T1Space Y
f_cont : Continuous f
x✝ : IsClosedMap f
H : ∀ (x : Y), (f ⁻¹' {x})ᶜ ∈ cocompact X
y : Y
K : Set X
hK : IsCompact K
hKy : Kᶜ ⊆ (f ⁻¹' {y})ᶜ
⊢ IsCompact (f ⁻¹' {y})
state_after: no goals
tactic: exact hK.of_isClosed_subset (isClosed_singleton.preimage f_cont)
    (compl_le_compl_iff_le.mp hKy)
Theorem: CoxeterSystem.isRightDescent_iff_not_isRightDescent_mul
File: Mathlib/GroupTheory/Coxeter/Length.lean

Proof steps:
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
⊢ cs.IsRightDescent w i ↔ ¬cs.IsRightDescent (w * cs.simple i) i
state_after: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
⊢ cs.length (w * cs.simple i) + 1 = cs.length w ↔ cs.length w = cs.length (w * cs.simple i) + 1
tactic: rw [isRightDescent_iff, not_isRightDescent_iff, simple_mul_simple_cancel_right]
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
⊢ cs.length (w * cs.simple i) + 1 = cs.length w ↔ cs.length w = cs.length (w * cs.simple i) + 1
state_after: no goals
tactic: tauto
Theorem: Filter.cofinite.blimsup_set_eq
File: Mathlib/Order/LiminfLimsup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
p : ι → Prop
s : ι → Set α
𝓕 : Filter ι
a : α
⊢ blimsup s cofinite p = {x | {n | p n ∧ x ∈ s n}.Infinite}
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
p : ι → Prop
s : ι → Set α
𝓕 : Filter ι
a : α
⊢ ⋂₀ {a | {x | p x ∧ ¬s x ⊆ a}.Finite} = {x | {n | p n ∧ x ∈ s n}.Infinite}
tactic: simp only [blimsup_eq, le_eq_subset, eventually_cofinite, not_forall, sInf_eq_sInter, exists_prop]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
p : ι → Prop
s : ι → Set α
𝓕 : Filter ι
a : α
⊢ ⋂₀ {a | {x | p x ∧ ¬s x ⊆ a}.Finite} = {x | {n | p n ∧ x ∈ s n}.Infinite}
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
p : ι → Prop
s : ι → Set α
𝓕 : Filter ι
a x : α
⊢ x ∈ ⋂₀ {a | {x | p x ∧ ¬s x ⊆ a}.Finite} ↔ x ∈ {x | {n | p n ∧ x ∈ s n}.Infinite}
tactic: ext x
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
p : ι → Prop
s : ι → Set α
𝓕 : Filter ι
a x : α
⊢ x ∈ ⋂₀ {a | {x | p x ∧ ¬s x ⊆ a}.Finite} ↔ x ∈ {x | {n | p n ∧ x ∈ s n}.Infinite}
state_after: case h.refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
p : ι → Prop
s : ι → Set α
𝓕 : Filter ι
a x : α
h : x ∉ {x | {n | p n ∧ x ∈ s n}.Infinite}
⊢ x ∉ ⋂₀ {a | {x | p x ∧ ¬s x ⊆ a}.Finite}

case h.refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
p : ι → Prop
s : ι → Set α
𝓕 : Filter ι
a x : α
hx : x ∈ {x | {n | p n ∧ x ∈ s n}.Infinite}
t : Set α
h : x ∉ t
⊢ t ∉ {a | {x | p x ∧ ¬s x ⊆ a}.Finite}
tactic: refine ⟨fun h => ?_, fun hx t h => ?_⟩ <;> contrapose! h
Theorem: Equiv.Perm.sign_subtypeCongr
File: Mathlib/GroupTheory/Perm/Sign.lean

Proof steps:
state_before: α : Type u
inst✝⁴ : DecidableEq α
β : Type v
inst✝³ : Fintype α
inst✝² : DecidableEq β
inst✝¹ : Fintype β
p : α → Prop
inst✝ : DecidablePred p
ep : Perm { a // p a }
en : Perm { a // ¬p a }
⊢ sign (ep.subtypeCongr en) = sign ep * sign en
state_after: no goals
tactic: simp [subtypeCongr]
Theorem: Orientation.neg_rotation_neg_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean

Proof steps:
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x : V
⊢ -(o.rotation ↑(-π / 2)) x = (o.rotation ↑(π / 2)) x
state_after: no goals
tactic: rw [neg_rotation, ← Real.Angle.coe_add, neg_div, ← sub_eq_add_neg, sub_half]
Theorem: MeasureTheory.cylinder_univ
File: Mathlib/MeasureTheory/Constructions/Cylinders.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
s : Finset ι
⊢ cylinder s univ = univ
state_after: no goals
tactic: rw [cylinder, preimage_univ]
Theorem: LinearMap.ofIsCompl_eq
File: Mathlib/LinearAlgebra/Projection.lean

Proof steps:
state_before: R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
p q : Submodule R E
S : Type u_5
inst✝² : Semiring S
M : Type u_6
inst✝¹ : AddCommMonoid M
inst✝ : Module S M
m : Submodule S M
h : IsCompl p q
φ : ↥p →ₗ[R] F
ψ : ↥q →ₗ[R] F
χ : E →ₗ[R] F
hφ : ∀ (u : ↥p), φ u = χ ↑u
hψ : ∀ (u : ↥q), ψ u = χ ↑u
⊢ ofIsCompl h φ ψ = χ
state_after: case h
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
p q : Submodule R E
S : Type u_5
inst✝² : Semiring S
M : Type u_6
inst✝¹ : AddCommMonoid M
inst✝ : Module S M
m : Submodule S M
h : IsCompl p q
φ : ↥p →ₗ[R] F
ψ : ↥q →ₗ[R] F
χ : E →ₗ[R] F
hφ : ∀ (u : ↥p), φ u = χ ↑u
hψ : ∀ (u : ↥q), ψ u = χ ↑u
x : E
⊢ (ofIsCompl h φ ψ) x = χ x
tactic: ext x
state_before: case h
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
p q : Submodule R E
S : Type u_5
inst✝² : Semiring S
M : Type u_6
inst✝¹ : AddCommMonoid M
inst✝ : Module S M
m : Submodule S M
h : IsCompl p q
φ : ↥p →ₗ[R] F
ψ : ↥q →ₗ[R] F
χ : E →ₗ[R] F
hφ : ∀ (u : ↥p), φ u = χ ↑u
hψ : ∀ (u : ↥q), ψ u = χ ↑u
x : E
⊢ (ofIsCompl h φ ψ) x = χ x
state_after: case h.intro.intro.intro
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
p q : Submodule R E
S : Type u_5
inst✝² : Semiring S
M : Type u_6
inst✝¹ : AddCommMonoid M
inst✝ : Module S M
m : Submodule S M
h : IsCompl p q
φ : ↥p →ₗ[R] F
ψ : ↥q →ₗ[R] F
χ : E →ₗ[R] F
hφ : ∀ (u : ↥p), φ u = χ ↑u
hψ : ∀ (u : ↥q), ψ u = χ ↑u
w✝¹ : ↥p
w✝ : ↥q
right✝ : ∀ (r : ↥p) (s : ↥q), ↑r + ↑s = ↑w✝¹ + ↑w✝ → r = w✝¹ ∧ s = w✝
⊢ (ofIsCompl h φ ψ) (↑w✝¹ + ↑w✝) = χ (↑w✝¹ + ↑w✝)
tactic: obtain ⟨_, _, rfl, _⟩ := existsUnique_add_of_isCompl h x
state_before: case h.intro.intro.intro
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
p q : Submodule R E
S : Type u_5
inst✝² : Semiring S
M : Type u_6
inst✝¹ : AddCommMonoid M
inst✝ : Module S M
m : Submodule S M
h : IsCompl p q
φ : ↥p →ₗ[R] F
ψ : ↥q →ₗ[R] F
χ : E →ₗ[R] F
hφ : ∀ (u : ↥p), φ u = χ ↑u
hψ : ∀ (u : ↥q), ψ u = χ ↑u
w✝¹ : ↥p
w✝ : ↥q
right✝ : ∀ (r : ↥p) (s : ↥q), ↑r + ↑s = ↑w✝¹ + ↑w✝ → r = w✝¹ ∧ s = w✝
⊢ (ofIsCompl h φ ψ) (↑w✝¹ + ↑w✝) = χ (↑w✝¹ + ↑w✝)
state_after: no goals
tactic: simp [ofIsCompl, hφ, hψ]
Theorem: neg_add_neg_iff
File: Mathlib/Algebra/Order/Group/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LT α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c : α
⊢ b < a * 1 ↔ b < a
state_after: no goals
tactic: rw [mul_one]
Theorem: CategoryTheory.isSeparator_iff_faithful_preadditiveCoyoneda
File: Mathlib/CategoryTheory/Preadditive/Generator.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Preadditive C
G : C
⊢ IsSeparator G ↔ (preadditiveCoyoneda.obj (op G)).Faithful
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Preadditive C
G : C
⊢ (preadditiveCoyoneda.obj (op G) ⋙ forget AddCommGrp).Faithful ↔ (preadditiveCoyoneda.obj (op G)).Faithful
tactic: rw [isSeparator_iff_faithful_coyoneda_obj, ← whiskering_preadditiveCoyoneda, Functor.comp_obj,
    whiskeringRight_obj_obj]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Preadditive C
G : C
⊢ (preadditiveCoyoneda.obj (op G) ⋙ forget AddCommGrp).Faithful ↔ (preadditiveCoyoneda.obj (op G)).Faithful
state_after: no goals
tactic: exact ⟨fun h => Functor.Faithful.of_comp _ (forget AddCommGrp),
    fun h => Functor.Faithful.comp _ _⟩
Theorem: SimpleGraph.locallyLinear_bot
File: Mathlib/Combinatorics/SimpleGraph/Triangle/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
𝕜 : Type u_3
inst✝ : LinearOrderedField 𝕜
G H : SimpleGraph α
ε δ : 𝕜
n : ℕ
s : Finset α
⊢ ⊥.LocallyLinear
state_after: no goals
tactic: simp [LocallyLinear]
Theorem: PFunctor.M.ichildren_mk
File: Mathlib/Data/PFunctor/Univariate/M.lean

Proof steps:
state_before: F : PFunctor.{u}
X : Type u_1
f : X → ↑F X
inst✝¹ : DecidableEq F.A
inst✝ : Inhabited F.M
x : ↑F F.M
i : F.Idx
⊢ ichildren i (M.mk x) = x.iget i
state_after: F : PFunctor.{u}
X : Type u_1
f : X → ↑F X
inst✝¹ : DecidableEq F.A
inst✝ : Inhabited F.M
x : ↑F F.M
i : F.Idx
⊢ (if H' : i.fst = (M.mk x).head then (M.mk x).children (cast ⋯ i.snd) else default) =
    if h : i.fst = x.fst then x.snd (cast ⋯ i.snd) else default
tactic: dsimp only [ichildren, PFunctor.Obj.iget]
state_before: F : PFunctor.{u}
X : Type u_1
f : X → ↑F X
inst✝¹ : DecidableEq F.A
inst✝ : Inhabited F.M
x : ↑F F.M
i : F.Idx
⊢ (if H' : i.fst = (M.mk x).head then (M.mk x).children (cast ⋯ i.snd) else default) =
    if h : i.fst = x.fst then x.snd (cast ⋯ i.snd) else default
state_after: no goals
tactic: congr with h
Theorem: CategoryTheory.Functor.pentagon
File: Mathlib/CategoryTheory/Whiskering.lean

Proof steps:
state_before: A : Type u₁
inst✝⁴ : Category.{v₁, u₁} A
B : Type u₂
inst✝³ : Category.{v₂, u₂} B
C : Type u₃
inst✝² : Category.{v₃, u₃} C
D : Type u₄
inst✝¹ : Category.{v₄, u₄} D
E : Type u₅
inst✝ : Category.{v₅, u₅} E
F : A ⥤ B
G : B ⥤ C
H : C ⥤ D
K : D ⥤ E
⊢ whiskerRight (F.associator G H).hom K ≫ (F.associator (G ⋙ H) K).hom ≫ whiskerLeft F (G.associator H K).hom =
    ((F ⋙ G).associator H K).hom ≫ (F.associator G (H ⋙ K)).hom
state_after: no goals
tactic: aesop_cat
Theorem: MulAction.orbitRel.quotient_eq_of_quotient_subgroup_eq
File: Mathlib/GroupTheory/GroupAction/Basic.lean

Proof steps:
state_before: G : Type u_1
α : Type u_2
β : Type u_3
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : MulAction G β
H : Subgroup G
a b : α
h : ⟦a⟧ = ⟦b⟧
⊢ ⟦a⟧ = ⟦b⟧
state_after: G : Type u_1
α : Type u_2
β : Type u_3
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : MulAction G β
H : Subgroup G
a b : α
h : a ≈ b
⊢ a ≈ b
tactic: rw [@Quotient.eq] at h ⊢
state_before: G : Type u_1
α : Type u_2
β : Type u_3
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : MulAction G β
H : Subgroup G
a b : α
h : a ≈ b
⊢ a ≈ b
state_after: no goals
tactic: exact mem_orbit_of_mem_orbit_subgroup h
Theorem: measurableSet_iSup_of_mem_piiUnionInter
File: Mathlib/MeasureTheory/PiSystem.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
m : ι → MeasurableSpace α
S : Set ι
t : Set α
ht : t ∈ piiUnionInter (fun n => {s | MeasurableSet s}) S
⊢ MeasurableSet t
state_after: case intro.intro.intro.intro
α : Type u_1
ι : Type u_2
m : ι → MeasurableSpace α
S : Set ι
pt : Finset ι
hpt : ↑pt ⊆ S
ft : ι → Set α
ht_m : ∀ x ∈ pt, ft x ∈ (fun n => {s | MeasurableSet s}) x
⊢ MeasurableSet (⋂ x ∈ pt, ft x)
tactic: rcases ht with ⟨pt, hpt, ft, ht_m, rfl⟩
state_before: case intro.intro.intro.intro
α : Type u_1
ι : Type u_2
m : ι → MeasurableSpace α
S : Set ι
pt : Finset ι
hpt : ↑pt ⊆ S
ft : ι → Set α
ht_m : ∀ x ∈ pt, ft x ∈ (fun n => {s | MeasurableSet s}) x
⊢ MeasurableSet (⋂ x ∈ pt, ft x)
state_after: case intro.intro.intro.intro
α : Type u_1
ι : Type u_2
m : ι → MeasurableSpace α
S : Set ι
pt : Finset ι
hpt : ↑pt ⊆ S
ft : ι → Set α
ht_m : ∀ x ∈ pt, ft x ∈ (fun n => {s | MeasurableSet s}) x
i : ι
hi : i ∈ pt
⊢ MeasurableSet (ft i)
tactic: refine pt.measurableSet_biInter fun i hi => ?_
state_before: case intro.intro.intro.intro
α : Type u_1
ι : Type u_2
m : ι → MeasurableSpace α
S : Set ι
pt : Finset ι
hpt : ↑pt ⊆ S
ft : ι → Set α
ht_m : ∀ x ∈ pt, ft x ∈ (fun n => {s | MeasurableSet s}) x
i : ι
hi : i ∈ pt
⊢ MeasurableSet (ft i)
state_after: case intro.intro.intro.intro
α : Type u_1
ι : Type u_2
m : ι → MeasurableSpace α
S : Set ι
pt : Finset ι
hpt : ↑pt ⊆ S
ft : ι → Set α
ht_m : ∀ x ∈ pt, ft x ∈ (fun n => {s | MeasurableSet s}) x
i : ι
hi : i ∈ pt
⊢ m i ≤ ⨆ i ∈ S, m i
tactic: suffices h_le : m i ≤ ⨆ i ∈ S, m i from h_le (ft i) (ht_m i hi)
state_before: case intro.intro.intro.intro
α : Type u_1
ι : Type u_2
m : ι → MeasurableSpace α
S : Set ι
pt : Finset ι
hpt : ↑pt ⊆ S
ft : ι → Set α
ht_m : ∀ x ∈ pt, ft x ∈ (fun n => {s | MeasurableSet s}) x
i : ι
hi : i ∈ pt
⊢ m i ≤ ⨆ i ∈ S, m i
state_after: case intro.intro.intro.intro
α : Type u_1
ι : Type u_2
m : ι → MeasurableSpace α
S : Set ι
pt : Finset ι
hpt : ↑pt ⊆ S
ft : ι → Set α
ht_m : ∀ x ∈ pt, ft x ∈ (fun n => {s | MeasurableSet s}) x
i : ι
hi : i ∈ pt
hi' : i ∈ S
⊢ m i ≤ ⨆ i ∈ S, m i
tactic: have hi' : i ∈ S := hpt hi
state_before: case intro.intro.intro.intro
α : Type u_1
ι : Type u_2
m : ι → MeasurableSpace α
S : Set ι
pt : Finset ι
hpt : ↑pt ⊆ S
ft : ι → Set α
ht_m : ∀ x ∈ pt, ft x ∈ (fun n => {s | MeasurableSet s}) x
i : ι
hi : i ∈ pt
hi' : i ∈ S
⊢ m i ≤ ⨆ i ∈ S, m i
state_after: no goals
tactic: exact le_iSup₂ (f := fun i (_ : i ∈ S) => m i) i hi'
Theorem: List.eraseP_eq_erasePTR
File: .lake/packages/batteries/Batteries/Data/List/Basic.lean

Proof steps:
state_before: ⊢ @eraseP = @erasePTR
state_after: case h.h.h
α : Type u_1
p : α → Bool
l : List α
⊢ eraseP p l = erasePTR p l
tactic: funext α p l
state_before: case h.h.h
α : Type u_1
p : α → Bool
l : List α
⊢ eraseP p l = erasePTR p l
state_after: case h.h.h
α : Type u_1
p : α → Bool
l : List α
⊢ eraseP p l = erasePTR.go p l l #[]
tactic: simp [erasePTR]
state_before: α : Type u_1
p : α → Bool
l : List α
acc : Array α
h : l = acc.data ++ []
⊢ erasePTR.go p l [] acc = acc.data ++ eraseP p []
state_after: no goals
tactic: simp [erasePTR.go, eraseP, h]
state_before: α : Type u_1
p : α → Bool
l : List α
acc : Array α
x : α
xs : List α
⊢ l = acc.data ++ x :: xs → erasePTR.go p l (x :: xs) acc = 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 acc.data ++ xs else erasePTR.go p l xs (acc.push x)) =
      acc.data ++ bif p x then xs else x :: eraseP p xs
tactic: simp [erasePTR.go, eraseP]
state_before: α : Type u_1
p : α → Bool
l : List α
acc : Array α
x : α
xs : List α
⊢ l = acc.data ++ x :: xs →
    (bif p x then acc.data ++ xs else erasePTR.go p l xs (acc.push x)) =
      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 → erasePTR.go p l xs (acc.push x) = acc.data ++ x :: eraseP p xs
tactic: cases p x <;> simp
state_before: case h.h.h
α : Type u_1
p : α → Bool
l : List α
⊢ eraseP p l = erasePTR.go p l l #[]
state_after: no goals
tactic: exact (go #[] _ rfl).symm
Theorem: EReal.top_add_iff_ne_bot
File: Mathlib/Data/Real/EReal.lean

Proof steps:
state_before: x : EReal
⊢ ⊤ + x = ⊤ ↔ x ≠ ⊥
state_after: case mp
x : EReal
h : ⊤ + x = ⊤
⊢ x ≠ ⊥

case mpr
x : EReal
h : x ≠ ⊥
⊢ ⊤ + x = ⊤
tactic: constructor <;> intro h
Theorem: Fin.predAbove_pred_of_le
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
p i : Fin (n + 1)
h : p ≤ i
hp : p ≠ 0
hi : optParam (i ≠ 0) ⋯
⊢ (p.pred hp).predAbove i = i.pred hi
state_after: no goals
tactic: rw [predAbove_of_succ_le _ _ (succ_pred _ _ ▸ h)]
Theorem: Rep.to_Module_monoidAlgebra_map_aux
File: Mathlib/RepresentationTheory/Rep.lean

Proof steps:
state_before: k✝ G✝ : Type u
inst✝⁷ : CommRing k✝
inst✝⁶ : Monoid G✝
k : Type u_1
G : Type u_2
inst✝⁵ : CommRing k
inst✝⁴ : Monoid G
V : Type u_3
W : Type u_4
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup W
inst✝¹ : Module k V
inst✝ : Module k W
ρ : G →* V →ₗ[k] V
σ : G →* W →ₗ[k] W
f : V →ₗ[k] W
w : ∀ (g : G), f ∘ₗ ρ g = σ g ∘ₗ f
r : MonoidAlgebra k G
x : V
⊢ f ((((MonoidAlgebra.lift k G (V →ₗ[k] V)) ρ) r) x) = (((MonoidAlgebra.lift k G (W →ₗ[k] W)) σ) r) (f x)
state_after: case hM
k✝ G✝ : Type u
inst✝⁷ : CommRing k✝
inst✝⁶ : Monoid G✝
k : Type u_1
G : Type u_2
inst✝⁵ : CommRing k
inst✝⁴ : Monoid G
V : Type u_3
W : Type u_4
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup W
inst✝¹ : Module k V
inst✝ : Module k W
ρ : G →* V →ₗ[k] V
σ : G →* W →ₗ[k] W
f : V →ₗ[k] W
w : ∀ (g : G), f ∘ₗ ρ g = σ g ∘ₗ f
r : MonoidAlgebra k G
x : V
⊢ ∀ (g : G),
    f ((((MonoidAlgebra.lift k G (V →ₗ[k] V)) ρ) ((MonoidAlgebra.of k G) g)) x) =
      (((MonoidAlgebra.lift k G (W →ₗ[k] W)) σ) ((MonoidAlgebra.of k G) g)) (f x)

case hadd
k✝ G✝ : Type u
inst✝⁷ : CommRing k✝
inst✝⁶ : Monoid G✝
k : Type u_1
G : Type u_2
inst✝⁵ : CommRing k
inst✝⁴ : Monoid G
V : Type u_3
W : Type u_4
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup W
inst✝¹ : Module k V
inst✝ : Module k W
ρ : G →* V →ₗ[k] V
σ : G →* W →ₗ[k] W
f : V →ₗ[k] W
w : ∀ (g : G), f ∘ₗ ρ g = σ g ∘ₗ f
r : MonoidAlgebra k G
x : V
⊢ ∀ (f_1 g : MonoidAlgebra k G),
    f ((((MonoidAlgebra.lift k G (V →ₗ[k] V)) ρ) f_1) x) = (((MonoidAlgebra.lift k G (W →ₗ[k] W)) σ) f_1) (f x) →
      f ((((MonoidAlgebra.lift k G (V →ₗ[k] V)) ρ) g) x) = (((MonoidAlgebra.lift k G (W →ₗ[k] W)) σ) g) (f x) →
        f ((((MonoidAlgebra.lift k G (V →ₗ[k] V)) ρ) (f_1 + g)) x) =
          (((MonoidAlgebra.lift k G (W →ₗ[k] W)) σ) (f_1 + g)) (f x)

case hsmul
k✝ G✝ : Type u
inst✝⁷ : CommRing k✝
inst✝⁶ : Monoid G✝
k : Type u_1
G : Type u_2
inst✝⁵ : CommRing k
inst✝⁴ : Monoid G
V : Type u_3
W : Type u_4
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup W
inst✝¹ : Module k V
inst✝ : Module k W
ρ : G →* V →ₗ[k] V
σ : G →* W →ₗ[k] W
f : V →ₗ[k] W
w : ∀ (g : G), f ∘ₗ ρ g = σ g ∘ₗ f
r : MonoidAlgebra k G
x : V
⊢ ∀ (r : k) (f_1 : MonoidAlgebra k G),
    f ((((MonoidAlgebra.lift k G (V →ₗ[k] V)) ρ) f_1) x) = (((MonoidAlgebra.lift k G (W →ₗ[k] W)) σ) f_1) (f x) →
      f ((((MonoidAlgebra.lift k G (V →ₗ[k] V)) ρ) (r • f_1)) x) =
        (((MonoidAlgebra.lift k G (W →ₗ[k] W)) σ) (r • f_1)) (f x)
tactic: apply MonoidAlgebra.induction_on r
Theorem: Finset.mem_neg'
File: Mathlib/Data/Finset/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : DecidableEq α
inst✝ : InvolutiveInv α
s : Finset α
a : α
⊢ a ∈ s⁻¹ ↔ a⁻¹ ∈ s
state_after: no goals
tactic: simp [mem_inv, inv_eq_iff_eq_inv]
Theorem: Multiset.revzip_powersetAux_lemma
File: Mathlib/Data/Multiset/Powerset.lean

Proof steps:
state_before: α✝ : Type u_1
α : Type u_2
inst✝ : DecidableEq α
l : List α
l' : List (Multiset α)
H : ∀ ⦃x : Multiset α × Multiset α⦄, x ∈ l'.revzip → x.1 + x.2 = ↑l
⊢ l'.revzip = List.map (fun x => (x, ↑l - x)) l'
state_after: α✝ : Type u_1
α : Type u_2
inst✝ : DecidableEq α
l : List α
l' : List (Multiset α)
H : ∀ ⦃x : Multiset α × Multiset α⦄, x ∈ l'.revzip → x.1 + x.2 = ↑l
this : Forall₂ (fun p s => p = (s, ↑l - s)) l'.revzip (List.map Prod.fst l'.revzip)
⊢ l'.revzip = List.map (fun x => (x, ↑l - x)) l'
tactic: have :
    Forall₂ (fun (p : Multiset α × Multiset α) (s : Multiset α) => p = (s, ↑l - s)) (revzip l')
      ((revzip l').map Prod.fst) := by
    rw [forall₂_map_right_iff, forall₂_same]
    rintro ⟨s, t⟩ h
    dsimp
    rw [← H h, add_tsub_cancel_left]
state_before: α✝ : Type u_1
α : Type u_2
inst✝ : DecidableEq α
l : List α
l' : List (Multiset α)
H : ∀ ⦃x : Multiset α × Multiset α⦄, x ∈ l'.revzip → x.1 + x.2 = ↑l
this : Forall₂ (fun p s => p = (s, ↑l - s)) l'.revzip (List.map Prod.fst l'.revzip)
⊢ l'.revzip = List.map (fun x => (x, ↑l - x)) l'
state_after: α✝ : Type u_1
α : Type u_2
inst✝ : DecidableEq α
l : List α
l' : List (Multiset α)
H : ∀ ⦃x : Multiset α × Multiset α⦄, x ∈ l'.revzip → x.1 + x.2 = ↑l
this : Forall₂ (fun p s => p = (s, ↑l - s)) l'.revzip (List.map Prod.fst l'.revzip)
⊢ Forall₂ (fun a c => a = (c, ↑l - c)) l'.revzip l'
tactic: rw [← forall₂_eq_eq_eq, forall₂_map_right_iff]
state_before: α✝ : Type u_1
α : Type u_2
inst✝ : DecidableEq α
l : List α
l' : List (Multiset α)
H : ∀ ⦃x : Multiset α × Multiset α⦄, x ∈ l'.revzip → x.1 + x.2 = ↑l
this : Forall₂ (fun p s => p = (s, ↑l - s)) l'.revzip (List.map Prod.fst l'.revzip)
⊢ Forall₂ (fun a c => a = (c, ↑l - c)) l'.revzip l'
state_after: no goals
tactic: simpa using this
Theorem: Nat.one_mem_divisors
File: Mathlib/NumberTheory/Divisors.lean

Proof steps:
state_before: n : ℕ
⊢ 1 ∈ n.divisors ↔ n ≠ 0
state_after: no goals
tactic: simp
Theorem: CoxeterSystem.exists_rightDescent_of_ne_one
File: Mathlib/GroupTheory/Coxeter/Length.lean

Proof steps:
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
hw : w ≠ 1
⊢ ∃ i, cs.IsRightDescent w i
state_after: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
hw : w ≠ 1
⊢ ∃ i, cs.IsLeftDescent w⁻¹ i
tactic: simp only [← isLeftDescent_inv_iff]
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
hw : w ≠ 1
⊢ ∃ i, cs.IsLeftDescent w⁻¹ i
state_after: case hw
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
hw : w ≠ 1
⊢ w⁻¹ ≠ 1
tactic: apply exists_leftDescent_of_ne_one
state_before: case hw
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
hw : w ≠ 1
⊢ w⁻¹ ≠ 1
state_after: no goals
tactic: simpa