ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.MonoidalFunctor.mapAction_toLaxMonoidalFunctor_μ_hom
File: Mathlib/RepresentationTheory/Action/Monoidal.lean

Proof steps:
state_before: V : Type (u + 1)
inst✝³ : LargeCategory V
G✝ : MonCat
W : Type (u + 1)
inst✝² : LargeCategory W
inst✝¹ : MonoidalCategory V
inst✝ : MonoidalCategory W
F : MonoidalFunctor V W
G : MonCat
⊢ IsIso __src✝.ε
state_after: V : Type (u + 1)
inst✝³ : LargeCategory V
G✝ : MonCat
W : Type (u + 1)
inst✝² : LargeCategory W
inst✝¹ : MonoidalCategory V
inst✝ : MonoidalCategory W
F : MonoidalFunctor V W
G : MonCat
⊢ IsIso { hom := F.ε, comm := ⋯ }
tactic: dsimp [mapActionLax]
state_before: V : Type (u + 1)
inst✝³ : LargeCategory V
G✝ : MonCat
W : Type (u + 1)
inst✝² : LargeCategory W
inst✝¹ : MonoidalCategory V
inst✝ : MonoidalCategory W
F : MonoidalFunctor V W
G : MonCat
⊢ IsIso { hom := F.ε, comm := ⋯ }
state_after: no goals
tactic: infer_instance
state_before: V : Type (u + 1)
inst✝³ : LargeCategory V
G✝ : MonCat
W : Type (u + 1)
inst✝² : LargeCategory W
inst✝¹ : MonoidalCategory V
inst✝ : MonoidalCategory W
F : MonoidalFunctor V W
G : MonCat
⊢ ∀ (X Y : Action V G), IsIso (__src✝.μ X Y)
state_after: V : Type (u + 1)
inst✝³ : LargeCategory V
G✝ : MonCat
W : Type (u + 1)
inst✝² : LargeCategory W
inst✝¹ : MonoidalCategory V
inst✝ : MonoidalCategory W
F : MonoidalFunctor V W
G : MonCat
⊢ ∀ (X Y : Action V G), IsIso { hom := F.μ X.V Y.V, comm := ⋯ }
tactic: dsimp [mapActionLax]
state_before: V : Type (u + 1)
inst✝³ : LargeCategory V
G✝ : MonCat
W : Type (u + 1)
inst✝² : LargeCategory W
inst✝¹ : MonoidalCategory V
inst✝ : MonoidalCategory W
F : MonoidalFunctor V W
G : MonCat
⊢ ∀ (X Y : Action V G), IsIso { hom := F.μ X.V Y.V, comm := ⋯ }
state_after: no goals
tactic: infer_instance
Theorem: Set.left_mem_Ico
File: Mathlib/Order/Interval/Set/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : Preorder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ a ∈ Ico a b ↔ a < b
state_after: no goals
tactic: simp [le_refl]
Theorem: Filter.bliminf_false
File: Mathlib/Order/LiminfLimsup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : CompleteLattice α
f : Filter β
u : β → α
⊢ (bliminf u f fun x => False) = ⊤
state_after: no goals
tactic: simp [bliminf_eq]
Theorem: MulAction.stabilizer_coe_finset
File: Mathlib/Algebra/Pointwise/Stabilizer.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
α : Type u_3
inst✝³ : Group G
inst✝² : Group H
inst✝¹ : MulAction G α
a : G
inst✝ : DecidableEq α
s : Finset α
⊢ stabilizer G ↑s = stabilizer G s
state_after: case h
G : Type u_1
H : Type u_2
α : Type u_3
inst✝³ : Group G
inst✝² : Group H
inst✝¹ : MulAction G α
a : G
inst✝ : DecidableEq α
s : Finset α
x✝ : G
⊢ x✝ ∈ stabilizer G ↑s ↔ x✝ ∈ stabilizer G s
tactic: ext
state_before: case h
G : Type u_1
H : Type u_2
α : Type u_3
inst✝³ : Group G
inst✝² : Group H
inst✝¹ : MulAction G α
a : G
inst✝ : DecidableEq α
s : Finset α
x✝ : G
⊢ x✝ ∈ stabilizer G ↑s ↔ x✝ ∈ stabilizer G s
state_after: no goals
tactic: simp [← Finset.coe_inj]
Theorem: IsLocalization.mk'_mul_mk'_eq_one
File: Mathlib/RingTheory/Localization/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
x y : ↥M
⊢ mk' S (↑x) y * mk' S (↑y) x = 1
state_after: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
x y : ↥M
⊢ mk' S (↑y * ↑x) (y * x) = 1
tactic: rw [← mk'_mul, mul_comm]
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
x y : ↥M
⊢ mk' S (↑y * ↑x) (y * x) = 1
state_after: no goals
tactic: exact mk'_self _ _
Theorem: _private.Mathlib.GroupTheory.Coxeter.Basic.0.CoxeterSystem.toMonoidHom_apply_symm_apply
File: Mathlib/GroupTheory/Coxeter/Basic.lean

Proof steps:
state_before: B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
a : PresentedGroup M.relationsSet
⊢ cs.mulEquiv.toMonoidHom (cs.mulEquiv.symm a) = cs.mulEquiv (cs.mulEquiv.symm a)
state_after: no goals
tactic: rfl
state_before: B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
a : PresentedGroup M.relationsSet
⊢ cs.mulEquiv (cs.mulEquiv.symm a) = a
state_after: no goals
tactic: rw [MulEquiv.apply_symm_apply]
Theorem: Finset.disjoint_insert_right
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
⊢ _root_.Disjoint (insert a t) s ↔ a ∉ s ∧ _root_.Disjoint s t
state_after: no goals
tactic: rw [disjoint_insert_left, _root_.disjoint_comm]
Theorem: mul_div_cancel_of_imp
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₀
inst✝ : GroupWithZero G₀
a b c d : G₀
m n : ℕ
h : b = 0 → a = 0
⊢ a * b / b = a
state_after: no goals
tactic: obtain rfl | hb := eq_or_ne b 0 <;>  simp [*]
Theorem: Zsqrtd.le_total
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

Proof steps:
state_before: d : ℕ
a b : ℤ√↑d
⊢ a ≤ b ∨ b ≤ a
state_after: d : ℕ
a b : ℤ√↑d
t : (b - a).Nonneg ∨ (-(b - a)).Nonneg
⊢ a ≤ b ∨ b ≤ a
tactic: have t := (b - a).nonneg_total
state_before: d : ℕ
a b : ℤ√↑d
t : (b - a).Nonneg ∨ (-(b - a)).Nonneg
⊢ a ≤ b ∨ b ≤ a
state_after: no goals
tactic: rwa [neg_sub] at t
Theorem: MvPowerSeries.constantCoeff_inv
File: Mathlib/RingTheory/MvPowerSeries/Inverse.lean

Proof steps:
state_before: σ : Type u_1
R : Type u_2
k : Type u_3
inst✝ : Field k
φ : MvPowerSeries σ k
⊢ (constantCoeff σ k) φ⁻¹ = ((constantCoeff σ k) φ)⁻¹
state_after: no goals
tactic: classical
  rw [← coeff_zero_eq_constantCoeff_apply, coeff_inv, if_pos rfl]
Theorem: Stream'.WSeq.liftRel_dropn_destruct
File: Mathlib/Data/Seq/WSeq.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
s : WSeq α
t : WSeq β
H : LiftRel R s t
n : ℕ
⊢ Computation.LiftRel (LiftRelO R (LiftRel R)) (s.drop (n + 1)).destruct (t.drop (n + 1)).destruct
state_after: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
s : WSeq α
t : WSeq β
H : LiftRel R s t
n : ℕ
⊢ Computation.LiftRel (LiftRelO R (LiftRel R)) ((s.drop n).destruct >>= tail.aux) ((t.drop n).destruct >>= tail.aux)
tactic: simp only [LiftRelO, drop, Nat.add_eq, Nat.add_zero, destruct_tail, tail.aux]
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
s : WSeq α
t : WSeq β
H : LiftRel R s t
n : ℕ
⊢ Computation.LiftRel (LiftRelO R (LiftRel R)) ((s.drop n).destruct >>= tail.aux) ((t.drop n).destruct >>= tail.aux)
state_after: case h1
α : Type u
β : Type v
γ : Type w
R : α → β → Prop
s : WSeq α
t : WSeq β
H : LiftRel R s t
n : ℕ
⊢ Computation.LiftRel ?R (s.drop n).destruct (t.drop n).destruct

case h2
α : Type u
β : Type v
γ : Type w
R : α → β → Prop
s : WSeq α
t : WSeq β
H : LiftRel R s t
n : ℕ
⊢ ∀ {a : Option (α × WSeq α)} {b : Option (β × WSeq β)},
    ?R a b → Computation.LiftRel (LiftRelO R (LiftRel R)) (tail.aux a) (tail.aux b)

case R
α : Type u
β : Type v
γ : Type w
R : α → β → Prop
s : WSeq α
t : WSeq β
H : LiftRel R s t
n : ℕ
⊢ Option (α × WSeq α) → Option (β × WSeq β) → Prop
tactic: apply liftRel_bind
state_before: case h2
α : Type u
β : Type v
γ : Type w
R : α → β → Prop
s : WSeq α
t : WSeq β
H : LiftRel R s t
n : ℕ
⊢ ∀ {a : Option (α × WSeq α)} {b : Option (β × WSeq β)},
    LiftRelO R (LiftRel R) a b → Computation.LiftRel (LiftRelO R (LiftRel R)) (tail.aux a) (tail.aux b)
state_after: no goals
tactic: exact fun {a b} o =>
      match a, b, o with
      | none, none, _ => by
        -- Porting note: These 2 theorems should be excluded.
        simp [-liftRel_pure_left, -liftRel_pure_right]
      | some (a, s), some (b, t), ⟨_, h2⟩ => by simpa [tail.aux] using liftRel_destruct h2
Theorem: Affine.Simplex.vectorSpan_isOrtho_altitude_direction
File: Mathlib/Geometry/Euclidean/MongePoint.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 1)
i : Fin (n + 2)
⊢ vectorSpan ℝ (s.points '' ↑(univ.erase i)) ⟂ (s.altitude i).direction
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 1)
i : Fin (n + 2)
⊢ vectorSpan ℝ (s.points '' ↑(univ.erase i)) ⟂
    (vectorSpan ℝ (s.points '' ↑(univ.erase i)))ᗮ ⊓ vectorSpan ℝ (Set.range s.points)
tactic: rw [direction_altitude]
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 1)
i : Fin (n + 2)
⊢ vectorSpan ℝ (s.points '' ↑(univ.erase i)) ⟂
    (vectorSpan ℝ (s.points '' ↑(univ.erase i)))ᗮ ⊓ vectorSpan ℝ (Set.range s.points)
state_after: no goals
tactic: exact (Submodule.isOrtho_orthogonal_right _).mono_right inf_le_left
Theorem: List.permutationsAux2_snd_eq
File: Mathlib/Data/List/Permutation.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
t : α
ts : List α
r : List β
ys : List α
f : List α → β
⊢ (permutationsAux2 t ts r ys f).2 = map (fun x => f (x ++ ts)) (permutationsAux2 t [] [] ys id).2 ++ r
state_after: no goals
tactic: rw [← permutationsAux2_append, map_permutationsAux2, permutationsAux2_comp_append]
Theorem: Lagrange.eval_interpolate_not_at_node'
File: Mathlib/LinearAlgebra/Lagrange.lean

Proof steps:
state_before: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s : Finset ι
v r : ι → F
i : ι
x : F
hvs : Set.InjOn v ↑s
hs : s.Nonempty
hx : ∀ i ∈ s, x ≠ v i
⊢ eval x ((interpolate s v) r) =
    (∑ i ∈ s, nodalWeight s v i * (x - v i)⁻¹ * r i) / ∑ i ∈ s, nodalWeight s v i * (x - v i)⁻¹
state_after: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s : Finset ι
v r : ι → F
i : ι
x : F
hvs : Set.InjOn v ↑s
hs : s.Nonempty
hx : ∀ i ∈ s, x ≠ v i
⊢ (eval x (nodal s v) * ∑ i ∈ s, nodalWeight s v i * (x - v i)⁻¹ * r i) /
      (eval x (nodal s v) * ∑ i ∈ s, nodalWeight s v i * (x - v i)⁻¹ * 1 i) =
    (∑ i ∈ s, nodalWeight s v i * (x - v i)⁻¹ * r i) / ∑ i ∈ s, nodalWeight s v i * (x - v i)⁻¹
tactic: rw [← div_one (eval x (interpolate s v r)), ← @eval_one _ _ x, ← interpolate_one hvs hs,
    eval_interpolate_not_at_node r hx, eval_interpolate_not_at_node 1 hx]
state_before: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s : Finset ι
v r : ι → F
i : ι
x : F
hvs : Set.InjOn v ↑s
hs : s.Nonempty
hx : ∀ i ∈ s, x ≠ v i
⊢ (eval x (nodal s v) * ∑ i ∈ s, nodalWeight s v i * (x - v i)⁻¹ * r i) /
      (eval x (nodal s v) * ∑ i ∈ s, nodalWeight s v i * (x - v i)⁻¹ * 1 i) =
    (∑ i ∈ s, nodalWeight s v i * (x - v i)⁻¹ * r i) / ∑ i ∈ s, nodalWeight s v i * (x - v i)⁻¹
state_after: no goals
tactic: simp only [mul_div_mul_left _ _ (eval_nodal_not_at_node hx), Pi.one_apply, mul_one]
Theorem: dvd_iff_exists_eq_mul_left
File: Mathlib/Algebra/Divisibility/Basic.lean

Proof steps:
state_before: α : Type u_1
inst✝ : CommSemigroup α
a b c : α
⊢ (∃ c, b = c * a) → a ∣ b
state_after: case intro
α : Type u_1
inst✝ : CommSemigroup α
a c✝ c : α
⊢ a ∣ c * a
tactic: rintro ⟨c, rfl⟩
state_before: case intro
α : Type u_1
inst✝ : CommSemigroup α
a c✝ c : α
⊢ a ∣ c * a
state_after: no goals
tactic: exact ⟨c, mul_comm _ _⟩
Theorem: Cardinal.mk_multiset_of_countable
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

Proof steps:
state_before: α : Type u
inst✝¹ : Countable α
inst✝ : Nonempty α
⊢ #(α →₀ ℕ) = ℵ₀
state_after: no goals
tactic: simp
Theorem: MeasureTheory.IsAddFundamentalDomain.setIntegral_eq_tsum
File: Mathlib/MeasureTheory/Group/FundamentalDomain.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝¹² : Group G
inst✝¹¹ : Group H
inst✝¹⁰ : MulAction G α
inst✝⁹ : MeasurableSpace α
inst✝⁸ : MulAction H β
inst✝⁷ : MeasurableSpace β
inst✝⁶ : NormedAddCommGroup E
s t✝ : Set α
μ : Measure α
inst✝⁵ : MeasurableSpace G
inst✝⁴ : MeasurableSMul G α
inst✝³ : SMulInvariantMeasure G α μ
inst✝² : Countable G
ν : Measure α
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
h : IsFundamentalDomain G s μ
f : α → E
t : Set α
hf : IntegrableOn f t μ
⊢ ∑' (g : G), ∫ (x : α) in g • s, f x ∂μ.restrict t = ∑' (g : G), ∫ (x : α) in t ∩ g • s, f x ∂μ
state_after: no goals
tactic: simp only [h.restrict_restrict, measure_smul, inter_comm]
Theorem: Matrix.blockTriangular_stdBasisMatrix
File: Mathlib/LinearAlgebra/Matrix/Block.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : Type u_3
n : Type u_4
o : Type u_5
m' : α → Type u_6
n' : α → Type u_7
R : Type v
inst✝² : CommRing R
M N : Matrix m m R
b : m → α
inst✝¹ : Preorder α
inst✝ : DecidableEq m
i j : m
hij : b i ≤ b j
c : R
⊢ (stdBasisMatrix i j c).BlockTriangular b
state_after: α : Type u_1
β : Type u_2
m : Type u_3
n : Type u_4
o : Type u_5
m' : α → Type u_6
n' : α → Type u_7
R : Type v
inst✝² : CommRing R
M N : Matrix m m R
b : m → α
inst✝¹ : Preorder α
inst✝ : DecidableEq m
i j : m
hij : b i ≤ b j
c : R
r s : m
hrs : b s < b r
⊢ stdBasisMatrix i j c r s = 0
tactic: intro r s hrs
state_before: α : Type u_1
β : Type u_2
m : Type u_3
n : Type u_4
o : Type u_5
m' : α → Type u_6
n' : α → Type u_7
R : Type v
inst✝² : CommRing R
M N : Matrix m m R
b : m → α
inst✝¹ : Preorder α
inst✝ : DecidableEq m
i j : m
hij : b i ≤ b j
c : R
r s : m
hrs : b s < b r
⊢ stdBasisMatrix i j c r s = 0
state_after: case h
α : Type u_1
β : Type u_2
m : Type u_3
n : Type u_4
o : Type u_5
m' : α → Type u_6
n' : α → Type u_7
R : Type v
inst✝² : CommRing R
M N : Matrix m m R
b : m → α
inst✝¹ : Preorder α
inst✝ : DecidableEq m
i j : m
hij : b i ≤ b j
c : R
r s : m
hrs : b s < b r
⊢ ¬(i = r ∧ j = s)
tactic: apply StdBasisMatrix.apply_of_ne
state_before: case h
α : Type u_1
β : Type u_2
m : Type u_3
n : Type u_4
o : Type u_5
m' : α → Type u_6
n' : α → Type u_7
R : Type v
inst✝² : CommRing R
M N : Matrix m m R
b : m → α
inst✝¹ : Preorder α
inst✝ : DecidableEq m
i j : m
hij : b i ≤ b j
c : R
r s : m
hrs : b s < b r
⊢ ¬(i = r ∧ j = s)
state_after: case h.intro
α : Type u_1
β : Type u_2
m : Type u_3
n : Type u_4
o : Type u_5
m' : α → Type u_6
n' : α → Type u_7
R : Type v
inst✝² : CommRing R
M N : Matrix m m R
b : m → α
inst✝¹ : Preorder α
inst✝ : DecidableEq m
i j : m
hij : b i ≤ b j
c : R
hrs : b j < b i
⊢ False
tactic: rintro ⟨rfl, rfl⟩
state_before: case h.intro
α : Type u_1
β : Type u_2
m : Type u_3
n : Type u_4
o : Type u_5
m' : α → Type u_6
n' : α → Type u_7
R : Type v
inst✝² : CommRing R
M N : Matrix m m R
b : m → α
inst✝¹ : Preorder α
inst✝ : DecidableEq m
i j : m
hij : b i ≤ b j
c : R
hrs : b j < b i
⊢ False
state_after: no goals
tactic: exact (hij.trans_lt hrs).false
Theorem: Polynomial.splits_prod
File: Mathlib/Algebra/Polynomial/Splits.lean

Proof steps:
state_before: R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝² : CommRing K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
ι : Type u
s : ι → K[X]
t : Finset ι
⊢ (∀ j ∈ t, Splits i (s j)) → Splits i (∏ x ∈ t, s x)
state_after: no goals
tactic: classical
  refine Finset.induction_on t (fun _ => splits_one i) fun a t hat ih ht => ?_
  rw [Finset.forall_mem_insert] at ht; rw [Finset.prod_insert hat]
  exact splits_mul i ht.1 (ih ht.2)
Theorem: ContinuousMap.ideal_isMaximal_iff
File: Mathlib/Topology/ContinuousFunction/Ideals.lean

Proof steps:
state_before: X : Type u_1
𝕜 : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : TopologicalSpace X
inst✝¹ : CompactSpace X
inst✝ : T2Space X
I : Ideal C(X, 𝕜)
hI : IsClosed ↑I
⊢ I.IsMaximal ↔ ∃ x, idealOfSet 𝕜 {x}ᶜ = I
state_after: X : Type u_1
𝕜 : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : TopologicalSpace X
inst✝¹ : CompactSpace X
inst✝ : T2Space X
I : Ideal C(X, 𝕜)
hI : IsClosed ↑I
⊢ I.IsMaximal → ∃ x, idealOfSet 𝕜 {x}ᶜ = I
tactic: refine
    ⟨?_, fun h =>
      let ⟨x, hx⟩ := h
      hx ▸ idealOf_compl_singleton_isMaximal 𝕜 x⟩
state_before: X : Type u_1
𝕜 : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : TopologicalSpace X
inst✝¹ : CompactSpace X
inst✝ : T2Space X
I : Ideal C(X, 𝕜)
hI : IsClosed ↑I
⊢ I.IsMaximal → ∃ x, idealOfSet 𝕜 {x}ᶜ = I
state_after: X : Type u_1
𝕜 : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : TopologicalSpace X
inst✝¹ : CompactSpace X
inst✝ : T2Space X
I : Ideal C(X, 𝕜)
hI : IsClosed ↑I
hI' : I.IsMaximal
⊢ ∃ x, idealOfSet 𝕜 {x}ᶜ = I
tactic: intro hI'
state_before: X : Type u_1
𝕜 : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : TopologicalSpace X
inst✝¹ : CompactSpace X
inst✝ : T2Space X
I : Ideal C(X, 𝕜)
hI : IsClosed ↑I
hI' : I.IsMaximal
⊢ ∃ x, idealOfSet 𝕜 {x}ᶜ = I
state_after: case intro
X : Type u_1
𝕜 : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : TopologicalSpace X
inst✝¹ : CompactSpace X
inst✝ : T2Space X
I : Ideal C(X, 𝕜)
hI : IsClosed ↑I
hI' : I.IsMaximal
x : X
hx : setOfIdeal I = {x}ᶜ
⊢ ∃ x, idealOfSet 𝕜 {x}ᶜ = I
tactic: obtain ⟨x, hx⟩ := setOfIdeal_eq_compl_singleton I
state_before: case intro
X : Type u_1
𝕜 : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : TopologicalSpace X
inst✝¹ : CompactSpace X
inst✝ : T2Space X
I : Ideal C(X, 𝕜)
hI : IsClosed ↑I
hI' : I.IsMaximal
x : X
hx : setOfIdeal I = {x}ᶜ
⊢ ∃ x, idealOfSet 𝕜 {x}ᶜ = I
state_after: no goals
tactic: exact
    ⟨x, by
      simpa only [idealOfSet_ofIdeal_eq_closure, I.closure_eq_of_isClosed hI] using
        congr_arg (idealOfSet 𝕜) hx.symm⟩
Theorem: List.map_add_range'
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: a s n step : Nat
⊢ map (fun x => a + x) (range' s (n + 1) step) = range' (a + s) (n + 1) step
state_after: no goals
tactic: simp [range', map_add_range' _ (s + step) n step, Nat.add_assoc]
Theorem: AddSubmonoid.LocalizationMap.neg_inj
File: Mathlib/GroupTheory/MonoidLocalization/Basic.lean

Proof steps:
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : M →* N
hf : ∀ (y : ↥S), IsUnit (f ↑y)
y z : ↥S
h : ((IsUnit.liftRight (f.restrict S) hf) y)⁻¹ = ((IsUnit.liftRight (f.restrict S) hf) z)⁻¹
⊢ f ↑y = f ↑z
state_after: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : M →* N
hf : ∀ (y : ↥S), IsUnit (f ↑y)
y z : ↥S
h : ((IsUnit.liftRight (f.restrict S) hf) y)⁻¹ = ((IsUnit.liftRight (f.restrict S) hf) z)⁻¹
⊢ f ↑z * ↑((IsUnit.liftRight (f.restrict S) hf) z)⁻¹ = 1
tactic: rw [← mul_one (f y), eq_comm, ← mul_inv_left hf y (f z) 1, h]
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : M →* N
hf : ∀ (y : ↥S), IsUnit (f ↑y)
y z : ↥S
h : ((IsUnit.liftRight (f.restrict S) hf) y)⁻¹ = ((IsUnit.liftRight (f.restrict S) hf) z)⁻¹
⊢ f ↑z * ↑((IsUnit.liftRight (f.restrict S) hf) z)⁻¹ = 1
state_after: no goals
tactic: exact Units.inv_mul (IsUnit.liftRight (f.restrict S) hf z)⁻¹
Theorem: ENNReal.lt_rpow_one_div_iff
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

Proof steps:
state_before: x y : ℝ≥0∞
z : ℝ
hz : 0 < z
⊢ x < y ^ (1 / z) ↔ x ^ z < y
state_after: x y : ℝ≥0∞
z : ℝ
hz : 0 < z
⊢ x ^ 1 < y ^ (1 / z) ↔ x ^ z < y
tactic: nth_rw 1 [← rpow_one x]
state_before: x y : ℝ≥0∞
z : ℝ
hz : 0 < z
⊢ x ^ 1 < y ^ (1 / z) ↔ x ^ z < y
state_after: x y : ℝ≥0∞
z : ℝ
hz : 0 < z
⊢ x ^ (z * z⁻¹) < y ^ (1 / z) ↔ x ^ z < y
tactic: nth_rw 1 [← @_root_.mul_inv_cancel _ _ z (ne_of_lt hz).symm]
state_before: x y : ℝ≥0∞
z : ℝ
hz : 0 < z
⊢ x ^ (z * z⁻¹) < y ^ (1 / z) ↔ x ^ z < y
state_after: no goals
tactic: rw [rpow_mul, ← one_div, @rpow_lt_rpow_iff _ _ (1 / z) (by simp [hz])]
Theorem: IntervalIntegrable.comp_sub_right
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedRing A
f g : ℝ → E
a b : ℝ
μ : Measure ℝ
hf : IntervalIntegrable f volume a b
c : ℝ
⊢ IntervalIntegrable (fun x => f (x - c)) volume (a + c) (b + c)
state_after: no goals
tactic: simpa only [sub_neg_eq_add] using IntervalIntegrable.comp_add_right hf (-c)
Theorem: Function.Semiconj.surjOn_range
File: Mathlib/Data/Set/Function.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
fa : α → α
fb : β → β
f : α → β
g : β → γ
s t : Set α
h : Semiconj f fa fb
ha : Surjective fa
⊢ SurjOn fb (range f) (range f)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
fa : α → α
fb : β → β
f : α → β
g : β → γ
s t : Set α
h : Semiconj f fa fb
ha : Surjective fa
⊢ SurjOn fb (f '' univ) (f '' univ)
tactic: rw [← image_univ]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
fa : α → α
fb : β → β
f : α → β
g : β → γ
s t : Set α
h : Semiconj f fa fb
ha : Surjective fa
⊢ SurjOn fb (f '' univ) (f '' univ)
state_after: no goals
tactic: exact h.surjOn_image (ha.surjOn univ)
Theorem: Directed.iSup_inf_eq
File: Mathlib/Order/CompactlyGenerated/Basic.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
inst✝² : CompleteLattice α
f : ι → α
inst✝¹ : CompleteLattice α
inst✝ : IsCompactlyGenerated α
a b : α
s : Set α
h : Directed (fun x x_1 => x ≤ x_1) f
⊢ (⨆ i, f i) ⊓ a = ⨆ i, f i ⊓ a
state_after: no goals
tactic: rw [iSup, h.directedOn_range.sSup_inf_eq, iSup_range]
Theorem: Part.toFinset_some
File: Mathlib/Data/Finset/PImage.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
a : α
inst✝ : Decidable (some a).Dom
⊢ (some a).toFinset = {a}
state_after: no goals
tactic: simp [toFinset]
Theorem: Iio_mem_nhdsSet_Ico
File: Mathlib/Topology/Order/NhdsSet.lean

Proof steps:
state_before: α : Type u_1
inst✝² : LinearOrder α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
a b c d : α
h : b ≤ c
⊢ Iio c ∈ 𝓝ˢ (Iio b)
state_after: no goals
tactic: simpa
Theorem: MeasureTheory.Measure.iInf_rat_gt_prod_Iic
File: Mathlib/Probability/Kernel/Disintegration/CdfToKernel.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α (β × ℝ)
ν : Kernel α β
f : α × β → ℚ → ℝ
ρ : Measure (α × ℝ)
inst✝ : IsFiniteMeasure ρ
s : Set α
hs : MeasurableSet s
t : ℚ
⊢ ⨅ r, ρ (s ×ˢ Iic ↑↑r) = ρ (s ×ˢ Iic ↑t)
state_after: α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α (β × ℝ)
ν : Kernel α β
f : α × β → ℚ → ℝ
ρ : Measure (α × ℝ)
inst✝ : IsFiniteMeasure ρ
s : Set α
hs : MeasurableSet s
t : ℚ
⊢ ρ (⋂ i, s ×ˢ Iic ↑↑i) = ρ (s ×ˢ Iic ↑t)

case h
α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α (β × ℝ)
ν : Kernel α β
f : α × β → ℚ → ℝ
ρ : Measure (α × ℝ)
inst✝ : IsFiniteMeasure ρ
s : Set α
hs : MeasurableSet s
t : ℚ
⊢ ∀ (i : { r' // t < r' }), MeasurableSet (s ×ˢ Iic ↑↑i)

case hd
α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α (β × ℝ)
ν : Kernel α β
f : α × β → ℚ → ℝ
ρ : Measure (α × ℝ)
inst✝ : IsFiniteMeasure ρ
s : Set α
hs : MeasurableSet s
t : ℚ
⊢ Directed (fun x x_1 => x ⊇ x_1) fun r => s ×ˢ Iic ↑↑r

case hfin
α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α (β × ℝ)
ν : Kernel α β
f : α × β → ℚ → ℝ
ρ : Measure (α × ℝ)
inst✝ : IsFiniteMeasure ρ
s : Set α
hs : MeasurableSet s
t : ℚ
⊢ ∃ i, ρ (s ×ˢ Iic ↑↑i) ≠ ⊤
tactic: rw [← measure_iInter_eq_iInf]