ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: List.orderedInsert_count
File: Mathlib/Data/List/Sort.lean

Proof steps:
state_before: α : Type u
r : α → α → Prop
inst✝¹ : DecidableRel r
inst✝ : DecidableEq α
L : List α
a b : α
⊢ count a (orderedInsert r b L) = count a L + if a = b then 1 else 0
state_after: no goals
tactic: rw [(L.perm_orderedInsert r b).count_eq, count_cons]
Theorem: eqRec_heq_iff_heq
File: .lake/packages/batteries/Batteries/Logic.lean

Proof steps:
state_before: α : Sort u_1
a : α
motive : (a' : α) → a = a' → Sort u_2
x : motive a ⋯
a' : α
e : a = a'
β : Sort u_2
y : β
⊢ HEq (e ▸ x) y ↔ HEq x y
state_after: α : Sort u_1
a : α
motive : (a' : α) → a = a' → Sort u_2
x : motive a ⋯
β : Sort u_2
y : β
⊢ HEq (⋯ ▸ x) y ↔ HEq x y
tactic: subst e
state_before: α : Sort u_1
a : α
motive : (a' : α) → a = a' → Sort u_2
x : motive a ⋯
β : Sort u_2
y : β
⊢ HEq (⋯ ▸ x) y ↔ HEq x y
state_after: no goals
tactic: rfl
Theorem: MeasureTheory.Integrable.measure_ge_lt_top
File: Mathlib/MeasureTheory/Function/L1Space.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ
hf : Integrable f μ
ε : ℝ
ε_pos : 0 < ε
⊢ μ {a | ε ≤ f a} < ⊤
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ
hf : Integrable f μ
ε : ℝ
ε_pos : 0 < ε
⊢ {a | ε ≤ f a} ⊆ {x | ε ≤ ‖f x‖}
tactic: refine lt_of_le_of_lt (measure_mono ?_) (hf.measure_norm_ge_lt_top ε_pos)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ
hf : Integrable f μ
ε : ℝ
ε_pos : 0 < ε
⊢ {a | ε ≤ f a} ⊆ {x | ε ≤ ‖f x‖}
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ
hf : Integrable f μ
ε : ℝ
ε_pos : 0 < ε
x : α
hx : x ∈ {a | ε ≤ f a}
⊢ x ∈ {x | ε ≤ ‖f x‖}
tactic: intro x hx
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ
hf : Integrable f μ
ε : ℝ
ε_pos : 0 < ε
x : α
hx : x ∈ {a | ε ≤ f a}
⊢ x ∈ {x | ε ≤ ‖f x‖}
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ
hf : Integrable f μ
ε : ℝ
ε_pos : 0 < ε
x : α
hx : ε ≤ f x
⊢ ε ≤ |f x|
tactic: simp only [Real.norm_eq_abs, Set.mem_setOf_eq] at hx ⊢
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ
hf : Integrable f μ
ε : ℝ
ε_pos : 0 < ε
x : α
hx : ε ≤ f x
⊢ ε ≤ |f x|
state_after: no goals
tactic: exact hx.trans (le_abs_self _)
Theorem: Traversable.traverse_eq_map_id'
File: Mathlib/Control/Traversable/Lemmas.lean

Proof steps:
state_before: t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g : α → F β
h : β → G γ
f✝ : β → γ
x : t β
f : β → γ
⊢ traverse (pure ∘ f) = pure ∘ map f
state_after: case h
t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g : α → F β
h : β → G γ
f✝ : β → γ
x : t β
f : β → γ
x✝ : t β
⊢ traverse (pure ∘ f) x✝ = (pure ∘ map f) x✝
tactic: ext
state_before: case h
t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g : α → F β
h : β → G γ
f✝ : β → γ
x : t β
f : β → γ
x✝ : t β
⊢ traverse (pure ∘ f) x✝ = (pure ∘ map f) x✝
state_after: no goals
tactic: exact traverse_eq_map_id _ _
Theorem: Int.floor_sub_int
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✝ a : α
z : ℤ
⊢ ⌊a - ↑z⌋ = ⌊a + ↑(-z)⌋
state_after: no goals
tactic: rw [Int.cast_neg, sub_eq_add_neg]
Theorem: Nat.modEq_list_prod_iff'
File: Mathlib/Data/Nat/ChineseRemainder.lean

Proof steps:
state_before: ι : Type u_1
a b : ℕ
s : ι → ℕ
l : List ι
co : List.Pairwise (Coprime on s) l
⊢ a ≡ b [MOD (List.map s l).prod] ↔ ∀ i ∈ l, a ≡ b [MOD s i]
state_after: case nil
ι : Type u_1
a b : ℕ
s : ι → ℕ
co : List.Pairwise (Coprime on s) []
⊢ a ≡ b [MOD (List.map s []).prod] ↔ ∀ i ∈ [], a ≡ b [MOD s i]

case cons
ι : Type u_1
a b : ℕ
s : ι → ℕ
i : ι
l : List ι
ih : List.Pairwise (Coprime on s) l → (a ≡ b [MOD (List.map s l).prod] ↔ ∀ i ∈ l, a ≡ b [MOD s i])
co : List.Pairwise (Coprime on s) (i :: l)
⊢ a ≡ b [MOD (List.map s (i :: l)).prod] ↔ ∀ i_1 ∈ i :: l, a ≡ b [MOD s i_1]
tactic: induction' l with i l ih
Theorem: Equiv.swap_eq_update
File: Mathlib/Logic/Equiv/Basic.lean

Proof steps:
state_before: α : Sort u_1
inst✝ : DecidableEq α
i j x : α
⊢ (swap i j) x = update (update id j i) i j x
state_after: no goals
tactic: rw [update_apply _ i j, update_apply _ j i, Equiv.swap_apply_def, id]
Theorem: Subgroup.MemLeftTransversals.toEquiv_apply
File: Mathlib/GroupTheory/Complement.lean

Proof steps:
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
f : G ⧸ H → G
hf : ∀ (q : G ⧸ H), ↑(f q) = q
q : G ⧸ H
⊢ ↑((toEquiv ⋯) q) = f q
state_after: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
f : G ⧸ H → G
hf : ∀ (q : G ⧸ H), ↑(f q) = q
q : G ⧸ H
⊢ (toEquiv ⋯) q = ⟨f q, ⋯⟩
tactic: refine (Subtype.ext_iff.mp ?_).trans (Subtype.coe_mk (f q) ⟨q, rfl⟩)
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
f : G ⧸ H → G
hf : ∀ (q : G ⧸ H), ↑(f q) = q
q : G ⧸ H
⊢ (toEquiv ⋯) q = ⟨f q, ⋯⟩
state_after: no goals
tactic: exact (toEquiv (range_mem_leftTransversals hf)).apply_eq_iff_eq_symm_apply.mpr (hf q).symm
Theorem: Set.OrdConnected.image_real_toNNReal
File: Mathlib/Data/NNReal/Basic.lean

Proof steps:
state_before: s : Set ℝ
t : Set ℝ≥0
h : s.OrdConnected
⊢ (toNNReal '' s).OrdConnected
state_after: s : Set ℝ
t : Set ℝ≥0
h : s.OrdConnected
x : ℝ
hx : x ∈ s
y : ℝ
hy : y ∈ s
z : ℝ≥0
hz : z ∈ Icc x.toNNReal y.toNNReal
⊢ z ∈ toNNReal '' s
tactic: refine ⟨forall_mem_image.2 fun x hx => forall_mem_image.2 fun y hy z hz => ?_⟩
state_before: s : Set ℝ
t : Set ℝ≥0
h : s.OrdConnected
x : ℝ
hx : x ∈ s
y : ℝ
hy : y ∈ s
z : ℝ≥0
hz : z ∈ Icc x.toNNReal y.toNNReal
⊢ z ∈ toNNReal '' s
state_after: case inl
s : Set ℝ
t : Set ℝ≥0
h : s.OrdConnected
x : ℝ
hx : x ∈ s
y : ℝ
hy : y ∈ s
z : ℝ≥0
hz : z ∈ Icc x.toNNReal y.toNNReal
hy₀ : y ≤ 0
⊢ z ∈ toNNReal '' s

case inr
s : Set ℝ
t : Set ℝ≥0
h : s.OrdConnected
x : ℝ
hx : x ∈ s
y : ℝ
hy : y ∈ s
z : ℝ≥0
hz : z ∈ Icc x.toNNReal y.toNNReal
hy₀ : 0 ≤ y
⊢ z ∈ toNNReal '' s
tactic: rcases le_total y 0 with hy₀ | hy₀
Theorem: List.forall_mem_pwFilter
File: .lake/packages/batteries/Batteries/Data/List/Pairwise.lean

Proof steps:
state_before: α : Type u_1
R : α → α → Prop
inst✝ : DecidableRel R
neg_trans : ∀ {x y z : α}, R x z → R x y ∨ R y z
a : α
l : List α
⊢ (∀ (b : α), b ∈ pwFilter R l → R a b) ↔ ∀ (b : α), b ∈ l → R a b
state_after: α : Type u_1
R : α → α → Prop
inst✝ : DecidableRel R
neg_trans : ∀ {x y z : α}, R x z → R x y ∨ R y z
a : α
l : List α
⊢ (∀ (b : α), b ∈ pwFilter R l → R a b) → ∀ (b : α), b ∈ l → R a b
tactic: refine ⟨?_, fun h b hb => h _ <| pwFilter_subset (R := R) _ hb⟩
state_before: α : Type u_1
R : α → α → Prop
inst✝ : DecidableRel R
neg_trans : ∀ {x y z : α}, R x z → R x y ∨ R y z
a : α
l : List α
⊢ (∀ (b : α), b ∈ pwFilter R l → R a b) → ∀ (b : α), b ∈ l → R a b
state_after: no goals
tactic: induction l with
  | nil => exact fun _ _ h => (not_mem_nil _ h).elim
  | cons x l IH =>
    simp only [forall_mem_cons]
    if h : ∀ y ∈ pwFilter R l, R x y then
      simpa [pwFilter_cons_of_pos h] using fun r H => ⟨r, IH H⟩
    else
      refine pwFilter_cons_of_neg h ▸ fun H => ⟨?_, IH H⟩
      match e : find? (fun y => ¬R x y) (pwFilter R l) with
      | none => exact h.elim fun y hy => by simpa using find?_eq_none.1 e y hy
      | some k =>
        have := find?_some e
        apply (neg_trans (H k (mem_of_find?_eq_some e))).resolve_right
        rw [decide_eq_true_iff] at this; exact this
Theorem: Inducing.continuousVAdd
File: Mathlib/Topology/Algebra/MulAction.lean

Proof steps:
state_before: M : Type u_1
X : Type u_2
Y : Type u_3
α : Type u_4
inst✝⁶ : TopologicalSpace M
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : SMul M X
inst✝² : ContinuousSMul M X
f✝ : Y → M
g : Y → X
b : Y
s : Set Y
N : Type u_5
inst✝¹ : SMul N Y
inst✝ : TopologicalSpace N
f : N → M
hg : Inducing g
hf : Continuous f
hsmul : ∀ {c : N} {x : Y}, g (c • x) = f c • g x
⊢ Continuous fun p => p.1 • p.2
state_after: no goals
tactic: simpa only [hg.continuous_iff, Function.comp_def, hsmul]
      using (hf.comp continuous_fst).smul <| hg.continuous.comp continuous_snd
Theorem: Matroid.freeOn_basis_iff
File: Mathlib/Data/Matroid/Constructions.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
E B I X R J : Set α
⊢ (freeOn E).Basis I X ↔ I = X ∧ X ⊆ E
state_after: case mpr
α : Type u_1
M : Matroid α
E B I X R J : Set α
⊢ I = X ∧ X ⊆ E → (freeOn E).Basis I X
tactic: use fun h ↦ ⟨(freeOn_indep h.subset_ground).eq_of_basis h ,h.subset_ground⟩
state_before: case mpr
α : Type u_1
M : Matroid α
E B I X R J : Set α
⊢ I = X ∧ X ⊆ E → (freeOn E).Basis I X
state_after: case mpr.intro
α : Type u_1
M : Matroid α
E B I R J : Set α
hIE : I ⊆ E
⊢ (freeOn E).Basis I I
tactic: rintro ⟨rfl, hIE⟩
state_before: case mpr.intro
α : Type u_1
M : Matroid α
E B I R J : Set α
hIE : I ⊆ E
⊢ (freeOn E).Basis I I
state_after: no goals
tactic: exact (freeOn_indep hIE).basis_self
Theorem: ProbabilityTheory.mgf_pos'
File: Mathlib/Probability/Moments.lean

Proof steps:
state_before: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
hμ : μ ≠ 0
h_int_X : Integrable (fun ω => rexp (t * X ω)) μ
⊢ 0 < mgf X μ t
state_after: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
hμ : μ ≠ 0
h_int_X : Integrable (fun ω => rexp (t * X ω)) μ
⊢ 0 < ∫ (x : Ω), rexp (t * X x) ∂μ
tactic: simp_rw [mgf]
state_before: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
hμ : μ ≠ 0
h_int_X : Integrable (fun ω => rexp (t * X ω)) μ
⊢ 0 < ∫ (x : Ω), rexp (t * X x) ∂μ
state_after: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
hμ : μ ≠ 0
h_int_X : Integrable (fun ω => rexp (t * X ω)) μ
this : ∫ (x : Ω), rexp (t * X x) ∂μ = ∫ (x : Ω) in Set.univ, rexp (t * X x) ∂μ
⊢ 0 < ∫ (x : Ω), rexp (t * X x) ∂μ
tactic: have : ∫ x : Ω, exp (t * X x) ∂μ = ∫ x : Ω in Set.univ, exp (t * X x) ∂μ := by
    simp only [Measure.restrict_univ]
state_before: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
hμ : μ ≠ 0
h_int_X : Integrable (fun ω => rexp (t * X ω)) μ
this : ∫ (x : Ω), rexp (t * X x) ∂μ = ∫ (x : Ω) in Set.univ, rexp (t * X x) ∂μ
⊢ 0 < ∫ (x : Ω), rexp (t * X x) ∂μ
state_after: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
hμ : μ ≠ 0
h_int_X : Integrable (fun ω => rexp (t * X ω)) μ
this : ∫ (x : Ω), rexp (t * X x) ∂μ = ∫ (x : Ω) in Set.univ, rexp (t * X x) ∂μ
⊢ 0 < μ ((Function.support fun x => rexp (t * X x)) ∩ Set.univ)

Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
hμ : μ ≠ 0
h_int_X : Integrable (fun ω => rexp (t * X ω)) μ
this : ∫ (x : Ω), rexp (t * X x) ∂μ = ∫ (x : Ω) in Set.univ, rexp (t * X x) ∂μ
⊢ 0 ≤ᶠ[ae (μ.restrict Set.univ)] fun x => rexp (t * X x)

Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
hμ : μ ≠ 0
h_int_X : Integrable (fun ω => rexp (t * X ω)) μ
this : ∫ (x : Ω), rexp (t * X x) ∂μ = ∫ (x : Ω) in Set.univ, rexp (t * X x) ∂μ
⊢ IntegrableOn (fun x => rexp (t * X x)) Set.univ μ
tactic: rw [this, setIntegral_pos_iff_support_of_nonneg_ae _ _]
Theorem: VAdd.vadd_lt_vadd_of_le_of_lt
File: Mathlib/Algebra/Order/AddTorsor.lean

Proof steps:
state_before: G : Type u_1
P : Type u_2
inst✝³ : LE G
inst✝² : Preorder P
inst✝¹ : SMul G P
inst✝ : IsOrderedCancelSMul G P
a b : G
c d : P
h₁ : a ≤ b
h₂ : c < d
⊢ a • c < b • d
state_after: G : Type u_1
P : Type u_2
inst✝³ : LE G
inst✝² : Preorder P
inst✝¹ : SMul G P
inst✝ : IsOrderedCancelSMul G P
a b : G
c d : P
h₁ : a ≤ b
h₂ : c < d
⊢ b • c < b • d
tactic: refine lt_of_le_of_lt (IsOrderedSMul.smul_le_smul_right a b h₁ c) ?_
state_before: G : Type u_1
P : Type u_2
inst✝³ : LE G
inst✝² : Preorder P
inst✝¹ : SMul G P
inst✝ : IsOrderedCancelSMul G P
a b : G
c d : P
h₁ : a ≤ b
h₂ : c < d
⊢ b • c < b • d
state_after: G : Type u_1
P : Type u_2
inst✝³ : LE G
inst✝² : Preorder P
inst✝¹ : SMul G P
inst✝ : IsOrderedCancelSMul G P
a b : G
c d : P
h₁ : a ≤ b
h₂ : c < d
⊢ ¬b • d ≤ b • c
tactic: refine lt_of_le_not_le (IsOrderedSMul.smul_le_smul_left c d (le_of_lt h₂) b) ?_
state_before: G : Type u_1
P : Type u_2
inst✝³ : LE G
inst✝² : Preorder P
inst✝¹ : SMul G P
inst✝ : IsOrderedCancelSMul G P
a b : G
c d : P
h₁ : a ≤ b
h₂ : c < d
⊢ ¬b • d ≤ b • c
state_after: G : Type u_1
P : Type u_2
inst✝³ : LE G
inst✝² : Preorder P
inst✝¹ : SMul G P
inst✝ : IsOrderedCancelSMul G P
a b : G
c d : P
h₁ : a ≤ b
h₂ : c < d
hbdc : b • d ≤ b • c
⊢ False
tactic: by_contra hbdc
state_before: G : Type u_1
P : Type u_2
inst✝³ : LE G
inst✝² : Preorder P
inst✝¹ : SMul G P
inst✝ : IsOrderedCancelSMul G P
a b : G
c d : P
h₁ : a ≤ b
h₂ : c < d
hbdc : b • d ≤ b • c
⊢ False
state_after: G : Type u_1
P : Type u_2
inst✝³ : LE G
inst✝² : Preorder P
inst✝¹ : SMul G P
inst✝ : IsOrderedCancelSMul G P
a b : G
c d : P
h₁ : a ≤ b
h₂ : c < d
hbdc : b • d ≤ b • c
h : d ≤ c
⊢ False
tactic: have h : d ≤ c := IsOrderedCancelSMul.le_of_smul_le_smul_left b d c hbdc
state_before: G : Type u_1
P : Type u_2
inst✝³ : LE G
inst✝² : Preorder P
inst✝¹ : SMul G P
inst✝ : IsOrderedCancelSMul G P
a b : G
c d : P
h₁ : a ≤ b
h₂ : c < d
hbdc : b • d ≤ b • c
h : d ≤ c
⊢ False
state_after: G : Type u_1
P : Type u_2
inst✝³ : LE G
inst✝² : Preorder P
inst✝¹ : SMul G P
inst✝ : IsOrderedCancelSMul G P
a b : G
c d : P
h₁ : a ≤ b
h₂ : c ≤ d ∧ ¬d ≤ c
hbdc : b • d ≤ b • c
h : d ≤ c
⊢ False
tactic: rw [@lt_iff_le_not_le] at h₂
state_before: G : Type u_1
P : Type u_2
inst✝³ : LE G
inst✝² : Preorder P
inst✝¹ : SMul G P
inst✝ : IsOrderedCancelSMul G P
a b : G
c d : P
h₁ : a ≤ b
h₂ : c ≤ d ∧ ¬d ≤ c
hbdc : b • d ≤ b • c
h : d ≤ c
⊢ False
state_after: no goals
tactic: simp_all only [not_true_eq_false, and_false]
Theorem: RatFunc.map_apply_ofFractionRing_mk
File: Mathlib/FieldTheory/RatFunc/Basic.lean

Proof steps:
state_before: K : Type u
inst✝⁶ : CommRing K
G₀ : Type u_1
L : Type u_2
R : Type u_3
S : Type u_4
F : Type u_5
inst✝⁵ : CommGroupWithZero G₀
inst✝⁴ : Field L
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : FunLike F R[X] S[X]
inst✝ : MonoidHomClass F R[X] S[X]
φ : F
hφ : R[X]⁰ ≤ Submonoid.comap φ S[X]⁰
n : R[X]
d : ↥R[X]⁰
⊢ (map φ hφ) { toFractionRing := Localization.mk n d } = { toFractionRing := Localization.mk (φ n) ⟨φ ↑d, ⋯⟩ }
state_after: K : Type u
inst✝⁶ : CommRing K
G₀ : Type u_1
L : Type u_2
R : Type u_3
S : Type u_4
F : Type u_5
inst✝⁵ : CommGroupWithZero G₀
inst✝⁴ : Field L
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : FunLike F R[X] S[X]
inst✝ : MonoidHomClass F R[X] S[X]
φ : F
hφ : R[X]⁰ ≤ Submonoid.comap φ S[X]⁰
n : R[X]
d : ↥R[X]⁰
⊢ (if h : φ ↑d ∈ S[X]⁰ then { toFractionRing := Localization.mk (φ n) ⟨φ ↑d, h⟩ } else 0) =
    { toFractionRing := Localization.mk (φ n) ⟨φ ↑d, ⋯⟩ }
tactic: refine (liftOn_ofFractionRing_mk n _ _ _).trans ?_
state_before: K : Type u
inst✝⁶ : CommRing K
G₀ : Type u_1
L : Type u_2
R : Type u_3
S : Type u_4
F : Type u_5
inst✝⁵ : CommGroupWithZero G₀
inst✝⁴ : Field L
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : FunLike F R[X] S[X]
inst✝ : MonoidHomClass F R[X] S[X]
φ : F
hφ : R[X]⁰ ≤ Submonoid.comap φ S[X]⁰
n : R[X]
d : ↥R[X]⁰
⊢ (if h : φ ↑d ∈ S[X]⁰ then { toFractionRing := Localization.mk (φ n) ⟨φ ↑d, h⟩ } else 0) =
    { toFractionRing := Localization.mk (φ n) ⟨φ ↑d, ⋯⟩ }
state_after: no goals
tactic: rw [dif_pos]
Theorem: Ne.nhdsWithin_diff_singleton
File: Mathlib/Topology/Separation.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
x y : X
h : x ≠ y
s : Set X
⊢ 𝓝[s \ {y}] x = 𝓝[s] x
state_after: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
x y : X
h : x ≠ y
s : Set X
⊢ {y}ᶜ ∈ 𝓝[s] x
tactic: rw [diff_eq, inter_comm, nhdsWithin_inter_of_mem]
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
x y : X
h : x ≠ y
s : Set X
⊢ {y}ᶜ ∈ 𝓝[s] x
state_after: no goals
tactic: exact mem_nhdsWithin_of_mem_nhds (isOpen_ne.mem_nhds h)
Theorem: Nat.squarefree_iff_minSqFac
File: Mathlib/Data/Nat/Squarefree.lean

Proof steps:
state_before: s : Finset ℕ
m n✝ p n : ℕ
⊢ Squarefree n ↔ n.minSqFac = none
state_after: s : Finset ℕ
m n✝ p n : ℕ
this : n.MinSqFacProp n.minSqFac
⊢ Squarefree n ↔ n.minSqFac = none
tactic: have := minSqFac_has_prop n
state_before: s : Finset ℕ
m n✝ p n : ℕ
this : n.MinSqFacProp n.minSqFac
⊢ Squarefree n ↔ n.minSqFac = none
state_after: case mp
s : Finset ℕ
m n✝ p n : ℕ
this : n.MinSqFacProp n.minSqFac
H : Squarefree n
⊢ n.minSqFac = none

case mpr
s : Finset ℕ
m n✝ p n : ℕ
this : n.MinSqFacProp n.minSqFac
H : n.minSqFac = none
⊢ Squarefree n
tactic: constructor <;> intro H
Theorem: ENNReal.prod_rpow_of_ne_top
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

Proof steps:
state_before: ι : Type u_1
s : Finset ι
f : ι → ℝ≥0∞
hf : ∀ i ∈ s, f i ≠ ⊤
r : ℝ
⊢ ∏ i ∈ s, f i ^ r = (∏ i ∈ s, f i) ^ r
state_after: no goals
tactic: induction s using Finset.induction with
  | empty => simp
  | @insert i s hi ih =>
    have h2f : ∀ i ∈ s, f i ≠ ∞ := fun i hi ↦ hf i <| mem_insert_of_mem hi
    rw [prod_insert hi, prod_insert hi, ih h2f, ← mul_rpow_of_ne_top <| hf i <| mem_insert_self ..]
    apply prod_lt_top h2f |>.ne
Theorem: _private.Mathlib.Order.WellFounded.0.WellFounded.eq_strictMono_iff_eq_range_aux
File: Mathlib/Order/WellFounded.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r r' : α → α → Prop
inst✝¹ : LinearOrder β
inst✝ : PartialOrder γ
f g : β → γ
hf : StrictMono f
hg : StrictMono g
hfg : range f = range g
b : β
H : ∀ a < b, f a = g a
⊢ f b ≤ g b
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
r r' : α → α → Prop
inst✝¹ : LinearOrder β
inst✝ : PartialOrder γ
f g : β → γ
hf : StrictMono f
hg : StrictMono g
hfg : range f = range g
b : β
H : ∀ a < b, f a = g a
c : β
hc : f c = g b
⊢ f b ≤ g b
tactic: obtain ⟨c, hc⟩ : g b ∈ Set.range f := by
    rw [hfg]
    exact Set.mem_range_self b
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
r r' : α → α → Prop
inst✝¹ : LinearOrder β
inst✝ : PartialOrder γ
f g : β → γ
hf : StrictMono f
hg : StrictMono g
hfg : range f = range g
b : β
H : ∀ a < b, f a = g a
c : β
hc : f c = g b
⊢ f b ≤ g b
state_after: case intro.inl
α : Type u_1
β : Type u_2
γ : Type u_3
r r' : α → α → Prop
inst✝¹ : LinearOrder β
inst✝ : PartialOrder γ
f g : β → γ
hf : StrictMono f
hg : StrictMono g
hfg : range f = range g
b : β
H : ∀ a < b, f a = g a
c : β
hc : f c = g b
hcb : c < b
⊢ f b ≤ g b

case intro.inr
α : Type u_1
β : Type u_2
γ : Type u_3
r r' : α → α → Prop
inst✝¹ : LinearOrder β
inst✝ : PartialOrder γ
f g : β → γ
hf : StrictMono f
hg : StrictMono g
hfg : range f = range g
b : β
H : ∀ a < b, f a = g a
c : β
hc : f c = g b
hbc : b ≤ c
⊢ f b ≤ g b
tactic: cases' lt_or_le c b with hcb hbc
Theorem: List.range_eq_nil
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: n : Nat
⊢ range n = [] ↔ n = 0
state_after: no goals
tactic: rw [← length_eq_zero, length_range]
Theorem: Fin.map_valEmbedding_Ici
File: Mathlib/Order/Interval/Finset/Fin.lean

Proof steps:
state_before: n : ℕ
a b : Fin n
⊢ map valEmbedding (Ici a) = Icc (↑a) (n - 1)
state_after: n : ℕ
a : Fin n
⊢ map valEmbedding (Ici a) = Icc (↑a) (n - 1)
tactic: clear b
state_before: n : ℕ
a : Fin n
⊢ map valEmbedding (Ici a) = Icc (↑a) (n - 1)
state_after: case a
n : ℕ
a : Fin n
x : ℕ
⊢ x ∈ map valEmbedding (Ici a) ↔ x ∈ Icc (↑a) (n - 1)
tactic: ext x
state_before: case a
n : ℕ
a : Fin n
x : ℕ
⊢ x ∈ map valEmbedding (Ici a) ↔ x ∈ Icc (↑a) (n - 1)
state_after: case a
n : ℕ
a : Fin n
x : ℕ
⊢ (∃ a_1, a ≤ a_1 ∧ valEmbedding a_1 = x) ↔ ↑a ≤ x ∧ x ≤ n - 1
tactic: simp only [exists_prop, Embedding.coe_subtype, mem_Ici, mem_map, mem_Icc]
state_before: case a
n : ℕ
a : Fin n
x : ℕ
⊢ (∃ a_1, a ≤ a_1 ∧ valEmbedding a_1 = x) ↔ ↑a ≤ x ∧ x ≤ n - 1
state_after: case a.mp
n : ℕ
a : Fin n
x : ℕ
⊢ (∃ a_1, a ≤ a_1 ∧ valEmbedding a_1 = x) → ↑a ≤ x ∧ x ≤ n - 1

case a.mpr
n : ℕ
a : Fin n
x : ℕ
⊢ ↑a ≤ x ∧ x ≤ n - 1 → ∃ a_2, a ≤ a_2 ∧ valEmbedding a_2 = x
tactic: constructor
state_before: case a.mpr
n : ℕ
a : Fin n
x : ℕ
⊢ ↑a ≤ x ∧ x ≤ n - 1 → ∃ a_2, a ≤ a_2 ∧ valEmbedding a_2 = x
state_after: case a.mpr.zero
x : ℕ
a : Fin 0
⊢ ↑a ≤ x ∧ x ≤ 0 - 1 → ∃ a_2, a ≤ a_2 ∧ valEmbedding a_2 = x

case a.mpr.succ
x n✝ : ℕ
a : Fin (n✝ + 1)
⊢ ↑a ≤ x ∧ x ≤ n✝ + 1 - 1 → ∃ a_2, a ≤ a_2 ∧ valEmbedding a_2 = x
tactic: cases n
Theorem: Function.support_nonempty_iff
File: Mathlib/Algebra/Group/Support.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
A : Type u_3
B : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
inst✝² : One M
inst✝¹ : One N
inst✝ : One P
f : α → M
⊢ (mulSupport f).Nonempty ↔ f ≠ 1
state_after: no goals
tactic: rw [nonempty_iff_ne_empty, Ne, mulSupport_eq_empty_iff]
Theorem: lowerSemicontinuousAt_tsum
File: Mathlib/Topology/Semicontinuous.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : TopologicalSpace α
β : Type u_2
inst✝ : Preorder β
f✝ g : α → β
x : α
s t : Set α
y z : β
ι : Type u_3
f : ι → α → ℝ≥0∞
h : ∀ (i : ι), LowerSemicontinuousAt (f i) x
⊢ LowerSemicontinuousAt (fun x' => ∑' (i : ι), f i x') x
state_after: α : Type u_1
inst✝¹ : TopologicalSpace α
β : Type u_2
inst✝ : Preorder β
f✝ g : α → β
x : α
s t : Set α
y z : β
ι : Type u_3
f : ι → α → ℝ≥0∞
h : ∀ (i : ι), LowerSemicontinuousWithinAt (f i) univ x
⊢ LowerSemicontinuousWithinAt (fun x' => ∑' (i : ι), f i x') univ x
tactic: simp_rw [← lowerSemicontinuousWithinAt_univ_iff] at *
state_before: α : Type u_1
inst✝¹ : TopologicalSpace α
β : Type u_2
inst✝ : Preorder β
f✝ g : α → β
x : α
s t : Set α
y z : β
ι : Type u_3
f : ι → α → ℝ≥0∞
h : ∀ (i : ι), LowerSemicontinuousWithinAt (f i) univ x
⊢ LowerSemicontinuousWithinAt (fun x' => ∑' (i : ι), f i x') univ x
state_after: no goals
tactic: exact lowerSemicontinuousWithinAt_tsum h
Theorem: Function.Bijective.comp_right
File: Mathlib/Logic/Function/Basic.lean

Proof steps:
state_before: α : Sort u_1
β : Sort u_2
γ : Sort u_3
f : α → β
hf : Bijective f
g : α → γ
⊢ (fun g => g ∘ f) (g ∘ surjInv ⋯) = g
state_after: no goals
tactic: simp only [comp.assoc g _ f, (leftInverse_surjInv hf).comp_eq_id, comp_id]
Theorem: Subgroup.index_inf_ne_zero
File: Mathlib/GroupTheory/Index.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K L : Subgroup G
hH : H.index ≠ 0
hK : K.index ≠ 0
⊢ (H ⊓ K).index ≠ 0
state_after: G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K L : Subgroup G
hH : H.relindex ⊤ ≠ 0
hK : K.relindex ⊤ ≠ 0
⊢ (H ⊓ K).relindex ⊤ ≠ 0
tactic: rw [← relindex_top_right] at hH hK ⊢
state_before: G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K L : Subgroup G
hH : H.relindex ⊤ ≠ 0
hK : K.relindex ⊤ ≠ 0
⊢ (H ⊓ K).relindex ⊤ ≠ 0
state_after: no goals
tactic: exact relindex_inf_ne_zero hH hK
Theorem: WithZero.unzero_mul
File: Mathlib/Algebra/GroupWithZero/WithZero.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Mul α
x y : WithZero α
hxy : x * y ≠ 0
⊢ unzero hxy = unzero ⋯ * unzero ⋯
state_after: no goals
tactic: simp only [← coe_inj, coe_mul, coe_unzero]