ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Multiset.toFinset_nsmul
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ t s : Multiset α
h : 0 ≠ 0
⊢ (0 • s).toFinset = s.toFinset
state_after: no goals
tactic: contradiction
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ t s : Multiset α
n : ℕ
x✝ : n + 1 ≠ 0
⊢ ((n + 1) • s).toFinset = s.toFinset
state_after: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ t s : Multiset α
n : ℕ
x✝ : n + 1 ≠ 0
h : n = 0
⊢ ((n + 1) • s).toFinset = s.toFinset

case neg
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ t s : Multiset α
n : ℕ
x✝ : n + 1 ≠ 0
h : ¬n = 0
⊢ ((n + 1) • s).toFinset = s.toFinset
tactic: by_cases h : n = 0
Theorem: CategoryTheory.conjugateEquiv_symm_id
File: Mathlib/CategoryTheory/Adjunction/Mates.lean

Proof steps:
state_before: C : Type u₁
D : Type u₂
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Category.{v₂, u₂} D
L₁ L₂ : C ⥤ D
R₁ R₂ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
⊢ (conjugateEquiv adj₁ adj₁).symm (𝟙 R₁) = 𝟙 L₁
state_after: C : Type u₁
D : Type u₂
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Category.{v₂, u₂} D
L₁ L₂ : C ⥤ D
R₁ R₂ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
⊢ 𝟙 R₁ = (conjugateEquiv adj₁ adj₁) (𝟙 L₁)
tactic: rw [Equiv.symm_apply_eq]
state_before: C : Type u₁
D : Type u₂
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Category.{v₂, u₂} D
L₁ L₂ : C ⥤ D
R₁ R₂ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
⊢ 𝟙 R₁ = (conjugateEquiv adj₁ adj₁) (𝟙 L₁)
state_after: no goals
tactic: simp only [conjugateEquiv_id]
Theorem: Set.preimage_eq_preimage'
File: Mathlib/Data/Set/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : ι → α
s✝ t✝ s t : Set α
f : β → α
hs : s ⊆ range f
ht : t ⊆ range f
⊢ f ⁻¹' s = f ⁻¹' t ↔ s = t
state_after: case mp
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : ι → α
s✝ t✝ s t : Set α
f : β → α
hs : s ⊆ range f
ht : t ⊆ range f
⊢ f ⁻¹' s = f ⁻¹' t → s = t

case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : ι → α
s✝ t✝ s t : Set α
f : β → α
hs : s ⊆ range f
ht : t ⊆ range f
⊢ s = t → f ⁻¹' s = f ⁻¹' t
tactic: constructor
state_before: case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : ι → α
s✝ t✝ s t : Set α
f : β → α
hs : s ⊆ range f
ht : t ⊆ range f
⊢ s = t → f ⁻¹' s = f ⁻¹' t
state_after: case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : ι → α
s✝ t s : Set α
f : β → α
hs ht : s ⊆ range f
⊢ f ⁻¹' s = f ⁻¹' s
tactic: rintro rfl
state_before: case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : ι → α
s✝ t s : Set α
f : β → α
hs ht : s ⊆ range f
⊢ f ⁻¹' s = f ⁻¹' s
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.shiftFunctorAdd'_add_zero_inv_app
File: Mathlib/CategoryTheory/Shift/Basic.lean

Proof steps:
state_before: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a : A
X : C
⊢ (shiftFunctorAdd' C a 0 a ⋯).inv.app X = (shiftFunctorZero C A).hom.app ((shiftFunctor C a).obj X)
state_after: no goals
tactic: simpa using NatTrans.congr_app (congr_arg Iso.inv (shiftFunctorAdd'_add_zero C a)) X
Theorem: HahnSeries.single_pow
File: Mathlib/RingTheory/HahnSeries/Multiplication.lean

Proof steps:
state_before: Γ : Type u_1
Γ' : Type u_2
R : Type u_3
V : Type u_4
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : Semiring R
a : Γ
n : ℕ
r : R
⊢ (single a) r ^ n = (single (n • a)) (r ^ n)
state_after: case zero
Γ : Type u_1
Γ' : Type u_2
R : Type u_3
V : Type u_4
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : Semiring R
a : Γ
r : R
⊢ (single a) r ^ 0 = (single (0 • a)) (r ^ 0)

case succ
Γ : Type u_1
Γ' : Type u_2
R : Type u_3
V : Type u_4
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : Semiring R
a : Γ
r : R
n : ℕ
IH : (single a) r ^ n = (single (n • a)) (r ^ n)
⊢ (single a) r ^ (n + 1) = (single ((n + 1) • a)) (r ^ (n + 1))
tactic: induction' n with n IH
Theorem: Finsupp.cons_zero_zero
File: Mathlib/Data/Finsupp/Fin.lean

Proof steps:
state_before: n : ℕ
i : Fin n
M : Type u_1
inst✝ : Zero M
y : M
t : Fin (n + 1) →₀ M
s : Fin n →₀ M
⊢ cons 0 0 = 0
state_after: case h
n : ℕ
i : Fin n
M : Type u_1
inst✝ : Zero M
y : M
t : Fin (n + 1) →₀ M
s : Fin n →₀ M
a : Fin (n + 1)
⊢ (cons 0 0) a = 0 a
tactic: ext a
state_before: case h
n : ℕ
i : Fin n
M : Type u_1
inst✝ : Zero M
y : M
t : Fin (n + 1) →₀ M
s : Fin n →₀ M
a : Fin (n + 1)
⊢ (cons 0 0) a = 0 a
state_after: case pos
n : ℕ
i : Fin n
M : Type u_1
inst✝ : Zero M
y : M
t : Fin (n + 1) →₀ M
s : Fin n →₀ M
a : Fin (n + 1)
c : a = 0
⊢ (cons 0 0) a = 0 a

case neg
n : ℕ
i : Fin n
M : Type u_1
inst✝ : Zero M
y : M
t : Fin (n + 1) →₀ M
s : Fin n →₀ M
a : Fin (n + 1)
c : ¬a = 0
⊢ (cons 0 0) a = 0 a
tactic: by_cases c : a = 0
Theorem: CategoryTheory.FintypeCat.Action.isConnected_of_transitive
File: Mathlib/CategoryTheory/Galois/Examples.lean

Proof steps:
state_before: G : Type u
inst✝² : Group G
X : FintypeCat
inst✝¹ : MulAction G ↑X
inst✝ : MulAction.IsPretransitive G ↑X
h : Nonempty ↑X
Y : Action FintypeCat (MonCat.of G)
i : Y ⟶ Action.FintypeCat.ofMulAction G X
hm : Mono i
hni : IsInitial Y → False
⊢ IsIso i
state_after: case intro
G : Type u
inst✝² : Group G
X : FintypeCat
inst✝¹ : MulAction G ↑X
inst✝ : MulAction.IsPretransitive G ↑X
h : Nonempty ↑X
Y : Action FintypeCat (MonCat.of G)
i : Y ⟶ Action.FintypeCat.ofMulAction G X
hm : Mono i
hni : IsInitial Y → False
y : ↑Y.V
⊢ IsIso i
tactic: obtain ⟨(y : Y.V)⟩ := (not_initial_iff_fiber_nonempty (Action.forget _ _) Y).mp hni
state_before: case intro
G : Type u
inst✝² : Group G
X : FintypeCat
inst✝¹ : MulAction G ↑X
inst✝ : MulAction.IsPretransitive G ↑X
h : Nonempty ↑X
Y : Action FintypeCat (MonCat.of G)
i : Y ⟶ Action.FintypeCat.ofMulAction G X
hm : Mono i
hni : IsInitial Y → False
y : ↑Y.V
this : IsIso i.hom
⊢ IsIso i
state_after: no goals
tactic: apply isIso_of_reflects_iso i (Action.forget _ _)
Theorem: Monoid.CoprodI.mclosure_iUnion_range_of
File: Mathlib/GroupTheory/CoprodI.lean

Proof steps:
state_before: ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝ : Monoid N
⊢ Submonoid.closure (⋃ i, range ⇑of) = ⊤
state_after: no goals
tactic: simp [Submonoid.closure_iUnion]
Theorem: Finsupp.embDomain_mapRange
File: Mathlib/Data/Finsupp/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝¹ : Zero M
inst✝ : Zero N
f : α ↪ β
g : M → N
p : α →₀ M
hg : g 0 = 0
⊢ embDomain f (mapRange g hg p) = mapRange g hg (embDomain f p)
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝¹ : Zero M
inst✝ : Zero N
f : α ↪ β
g : M → N
p : α →₀ M
hg : g 0 = 0
a : β
⊢ (embDomain f (mapRange g hg p)) a = (mapRange g hg (embDomain f p)) a
tactic: ext a
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝¹ : Zero M
inst✝ : Zero N
f : α ↪ β
g : M → N
p : α →₀ M
hg : g 0 = 0
a : β
⊢ (embDomain f (mapRange g hg p)) a = (mapRange g hg (embDomain f p)) a
state_after: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝¹ : Zero M
inst✝ : Zero N
f : α ↪ β
g : M → N
p : α →₀ M
hg : g 0 = 0
a : β
h : a ∈ Set.range ⇑f
⊢ (embDomain f (mapRange g hg p)) a = (mapRange g hg (embDomain f p)) a

case neg
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝¹ : Zero M
inst✝ : Zero N
f : α ↪ β
g : M → N
p : α →₀ M
hg : g 0 = 0
a : β
h : a ∉ Set.range ⇑f
⊢ (embDomain f (mapRange g hg p)) a = (mapRange g hg (embDomain f p)) a
tactic: by_cases h : a ∈ Set.range f
Theorem: xor_iff_iff_not
File: Mathlib/Logic/Basic.lean

Proof steps:
state_before: a b : Prop
⊢ Xor' a b ↔ (a ↔ ¬b)
state_after: no goals
tactic: simp only [← @xor_not_right a, not_not]
Theorem: ContinuousMultilinearMap.norm_ofSubsingleton_id_le
File: Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean

Proof steps:
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
G : Type wG
G' : Type wG'
inst✝¹⁶ : Fintype ι
inst✝¹⁵ : Fintype ι'
inst✝¹⁴ : NontriviallyNormedField 𝕜
inst✝¹³ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝¹² : (i : ι) → NormedSpace 𝕜 (E i)
inst✝¹¹ : (i : ι) → SeminormedAddCommGroup (E₁ i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁹ : (i : ι') → SeminormedAddCommGroup (E' i)
inst✝⁸ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁷ : SeminormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
inst✝⁵ : SeminormedAddCommGroup G'
inst✝⁴ : NormedSpace 𝕜 G'
c : 𝕜
f g : ContinuousMultilinearMap 𝕜 E G
m : (i : ι) → E i
𝕜' : Type u_1
inst✝³ : NormedField 𝕜'
inst✝² : NormedSpace 𝕜' G
inst✝¹ : SMulCommClass 𝕜 𝕜' G
inst✝ : Subsingleton ι
i : ι
⊢ ‖(ofSubsingleton 𝕜 G G i) (ContinuousLinearMap.id 𝕜 G)‖ ≤ 1
state_after: 𝕜 : Type u
ι : Type v
ι' : Type v'
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
G : Type wG
G' : Type wG'
inst✝¹⁶ : Fintype ι
inst✝¹⁵ : Fintype ι'
inst✝¹⁴ : NontriviallyNormedField 𝕜
inst✝¹³ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝¹² : (i : ι) → NormedSpace 𝕜 (E i)
inst✝¹¹ : (i : ι) → SeminormedAddCommGroup (E₁ i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁹ : (i : ι') → SeminormedAddCommGroup (E' i)
inst✝⁸ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁷ : SeminormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
inst✝⁵ : SeminormedAddCommGroup G'
inst✝⁴ : NormedSpace 𝕜 G'
c : 𝕜
f g : ContinuousMultilinearMap 𝕜 E G
m : (i : ι) → E i
𝕜' : Type u_1
inst✝³ : NormedField 𝕜'
inst✝² : NormedSpace 𝕜' G
inst✝¹ : SMulCommClass 𝕜 𝕜' G
inst✝ : Subsingleton ι
i : ι
⊢ ‖ContinuousLinearMap.id 𝕜 G‖ ≤ 1
tactic: rw [norm_ofSubsingleton]
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
G : Type wG
G' : Type wG'
inst✝¹⁶ : Fintype ι
inst✝¹⁵ : Fintype ι'
inst✝¹⁴ : NontriviallyNormedField 𝕜
inst✝¹³ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝¹² : (i : ι) → NormedSpace 𝕜 (E i)
inst✝¹¹ : (i : ι) → SeminormedAddCommGroup (E₁ i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁹ : (i : ι') → SeminormedAddCommGroup (E' i)
inst✝⁸ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁷ : SeminormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
inst✝⁵ : SeminormedAddCommGroup G'
inst✝⁴ : NormedSpace 𝕜 G'
c : 𝕜
f g : ContinuousMultilinearMap 𝕜 E G
m : (i : ι) → E i
𝕜' : Type u_1
inst✝³ : NormedField 𝕜'
inst✝² : NormedSpace 𝕜' G
inst✝¹ : SMulCommClass 𝕜 𝕜' G
inst✝ : Subsingleton ι
i : ι
⊢ ‖ContinuousLinearMap.id 𝕜 G‖ ≤ 1
state_after: no goals
tactic: apply ContinuousLinearMap.norm_id_le
Theorem: Primrec.fst
File: Mathlib/Computability/Primrec.lean

Proof steps:
state_before: α✝ : Type u_1
σ : Type u_2
inst✝³ : Primcodable α✝
inst✝² : Primcodable σ
α : Type u_3
β : Type u_4
inst✝¹ : Primcodable α
inst✝ : Primcodable β
n : ℕ
⊢ Nat.unpaired
      (fun z n =>
        Nat.casesOn n 0 fun y =>
          Nat.unpaired (fun z n => Nat.casesOn n 0 fun y => (Nat.unpair (Nat.pair z y)).1.succ)
            (Nat.pair (Nat.unpair (Nat.pair z y)).2 (encode (decode (Nat.unpair (Nat.pair z y)).1))))
      (Nat.pair (Nat.unpair n).2 (encode (decode (Nat.unpair n).1))) =
    encode (Option.map Prod.fst (decode n))
state_after: α✝ : Type u_1
σ : Type u_2
inst✝³ : Primcodable α✝
inst✝² : Primcodable σ
α : Type u_3
β : Type u_4
inst✝¹ : Primcodable α
inst✝ : Primcodable β
n : ℕ
⊢ Nat.rec 0 (fun n_1 n_ih => Nat.rec 0 (fun n n_ih => n_1.succ) (encode (decode (Nat.unpair n).2)))
      (encode (decode (Nat.unpair n).1)) =
    encode
      (Option.map Prod.fst ((decode (Nat.unpair n).1).bind fun a => Option.map (Prod.mk a) (decode (Nat.unpair n).2)))
tactic: simp only [Nat.unpaired, Nat.unpair_pair, decode_prod_val]
state_before: α✝ : Type u_1
σ : Type u_2
inst✝³ : Primcodable α✝
inst✝² : Primcodable σ
α : Type u_3
β : Type u_4
inst✝¹ : Primcodable α
inst✝ : Primcodable β
n : ℕ
⊢ Nat.rec 0 (fun n_1 n_ih => Nat.rec 0 (fun n n_ih => n_1.succ) (encode (decode (Nat.unpair n).2)))
      (encode (decode (Nat.unpair n).1)) =
    encode
      (Option.map Prod.fst ((decode (Nat.unpair n).1).bind fun a => Option.map (Prod.mk a) (decode (Nat.unpair n).2)))
state_after: case some
α✝ : Type u_1
σ : Type u_2
inst✝³ : Primcodable α✝
inst✝² : Primcodable σ
α : Type u_3
β : Type u_4
inst✝¹ : Primcodable α
inst✝ : Primcodable β
n : ℕ
val✝ : α
⊢ Nat.rec 0 (fun n n_ih => encode val✝ + 1) (encode (decode (Nat.unpair n).2)) =
    encode (Option.map (Function.const β val✝) (decode (Nat.unpair n).2))
tactic: cases @decode α _ n.unpair.1 <;> simp
state_before: case some
α✝ : Type u_1
σ : Type u_2
inst✝³ : Primcodable α✝
inst✝² : Primcodable σ
α : Type u_3
β : Type u_4
inst✝¹ : Primcodable α
inst✝ : Primcodable β
n : ℕ
val✝ : α
⊢ Nat.rec 0 (fun n n_ih => encode val✝ + 1) (encode (decode (Nat.unpair n).2)) =
    encode (Option.map (Function.const β val✝) (decode (Nat.unpair n).2))
state_after: no goals
tactic: cases @decode β _ n.unpair.2 <;> simp
Theorem: add_ball
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

Proof steps:
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ s * ball x δ = x • thickening δ s
state_after: no goals
tactic: rw [← smul_ball_one, mul_smul_comm, mul_ball_one]
Theorem: UniformOnFun.hasBasis_nhds_zero_of_basis
File: Mathlib/Topology/Algebra/UniformConvergence.lean

Proof steps:
state_before: α : Type u_1
G : Type u_2
ι : Type u_3
inst✝² : Group G
𝔖✝ : Set (Set α)
inst✝¹ : UniformSpace G
inst✝ : UniformGroup G
𝔖 : Set (Set α)
h𝔖₁ : 𝔖.Nonempty
h𝔖₂ : DirectedOn (fun x x_1 => x ⊆ x_1) 𝔖
p : ι → Prop
b : ι → Set G
h : (𝓝 1).HasBasis p b
⊢ (𝓝 1).HasBasis (fun Si => Si.1 ∈ 𝔖 ∧ p Si.2) fun Si => {f | ∀ x ∈ Si.1, (toFun 𝔖) f x ∈ b Si.2}
state_after: α : Type u_1
G : Type u_2
ι : Type u_3
inst✝² : Group G
𝔖✝ : Set (Set α)
inst✝¹ : UniformSpace G
inst✝ : UniformGroup G
𝔖 : Set (Set α)
h𝔖₁ : 𝔖.Nonempty
h𝔖₂ : DirectedOn (fun x x_1 => x ⊆ x_1) 𝔖
p : ι → Prop
b : ι → Set G
h : (𝓝 1).HasBasis p b
this : (𝓤 G).HasBasis p fun i => {x | x.1 / x.2 ∈ b i}
⊢ (𝓝 1).HasBasis (fun Si => Si.1 ∈ 𝔖 ∧ p Si.2) fun Si => {f | ∀ x ∈ Si.1, (toFun 𝔖) f x ∈ b Si.2}
tactic: have := h.uniformity_of_nhds_one_swapped
state_before: α : Type u_1
G : Type u_2
ι : Type u_3
inst✝² : Group G
𝔖✝ : Set (Set α)
inst✝¹ : UniformSpace G
inst✝ : UniformGroup G
𝔖 : Set (Set α)
h𝔖₁ : 𝔖.Nonempty
h𝔖₂ : DirectedOn (fun x x_1 => x ⊆ x_1) 𝔖
p : ι → Prop
b : ι → Set G
h : (𝓝 1).HasBasis p b
this : (𝓤 G).HasBasis p fun i => {x | x.1 / x.2 ∈ b i}
⊢ (𝓝 1).HasBasis (fun Si => Si.1 ∈ 𝔖 ∧ p Si.2) fun Si => {f | ∀ x ∈ Si.1, (toFun 𝔖) f x ∈ b Si.2}
state_after: case h.e'_5.h.h.e'_2.h.a
α : Type u_1
G : Type u_2
ι : Type u_3
inst✝² : Group G
𝔖✝ : Set (Set α)
inst✝¹ : UniformSpace G
inst✝ : UniformGroup G
𝔖 : Set (Set α)
h𝔖₁ : 𝔖.Nonempty
h𝔖₂ : DirectedOn (fun x x_1 => x ⊆ x_1) 𝔖
p : ι → Prop
b : ι → Set G
h : (𝓝 1).HasBasis p b
this : (𝓤 G).HasBasis p fun i => {x | x.1 / x.2 ∈ b i}
x✝¹ : Set α × ι
x✝ : α →ᵤ[𝔖] G
⊢ (∀ x ∈ x✝¹.1, (toFun 𝔖) x✝ x ∈ b x✝¹.2) ↔ (x✝, 1) ∈ UniformOnFun.gen 𝔖 x✝¹.1 {x | x.1 / x.2 ∈ b x✝¹.2}
tactic: convert UniformOnFun.hasBasis_nhds_of_basis α _ 𝔖 (1 : α →ᵤ[𝔖] G) h𝔖₁ h𝔖₂ this
state_before: case h.e'_5.h.h.e'_2.h.a
α : Type u_1
G : Type u_2
ι : Type u_3
inst✝² : Group G
𝔖✝ : Set (Set α)
inst✝¹ : UniformSpace G
inst✝ : UniformGroup G
𝔖 : Set (Set α)
h𝔖₁ : 𝔖.Nonempty
h𝔖₂ : DirectedOn (fun x x_1 => x ⊆ x_1) 𝔖
p : ι → Prop
b : ι → Set G
h : (𝓝 1).HasBasis p b
this : (𝓤 G).HasBasis p fun i => {x | x.1 / x.2 ∈ b i}
x✝¹ : Set α × ι
x✝ : α →ᵤ[𝔖] G
⊢ (∀ x ∈ x✝¹.1, (toFun 𝔖) x✝ x ∈ b x✝¹.2) ↔ (x✝, 1) ∈ UniformOnFun.gen 𝔖 x✝¹.1 {x | x.1 / x.2 ∈ b x✝¹.2}
state_after: no goals
tactic: simp [UniformOnFun.gen]
Theorem: ENNReal.one_lt_rpow_of_pos_of_lt_one_of_neg
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

Proof steps:
state_before: x : ℝ≥0∞
z : ℝ
hx1 : 0 < x
hx2 : x < 1
hz : z < 0
⊢ 1 < x ^ z
state_after: case intro
z : ℝ
hz : z < 0
x : ℝ≥0
hx1 : 0 < ↑x
hx2 : ↑x < 1
⊢ 1 < ↑x ^ z
tactic: lift x to ℝ≥0 using ne_of_lt (lt_of_lt_of_le hx2 le_top)
state_before: case intro
z : ℝ
hz : z < 0
x : ℝ≥0
hx1 : 0 < ↑x
hx2 : ↑x < 1
⊢ 1 < ↑x ^ z
state_after: case intro
z : ℝ
hz : z < 0
x : ℝ≥0
hx1 : 0 < x
hx2 : x < 1
⊢ 1 < ↑x ^ z
tactic: simp only [coe_lt_one_iff, coe_pos] at hx1 hx2 ⊢
state_before: case intro
z : ℝ
hz : z < 0
x : ℝ≥0
hx1 : 0 < x
hx2 : x < 1
⊢ 1 < ↑x ^ z
state_after: no goals
tactic: simp [coe_rpow_of_ne_zero (ne_of_gt hx1), NNReal.one_lt_rpow_of_pos_of_lt_one_of_neg hx1 hx2 hz]
Theorem: Real.rpow_add
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

Proof steps:
state_before: x✝ y✝¹ z✝¹ w x y✝ z✝ : ℝ
hx : 0 < x
y z : ℝ
⊢ x ^ (y + z) = x ^ y * x ^ z
state_after: no goals
tactic: simp only [rpow_def_of_pos hx, mul_add, exp_add]
Theorem: PartialHomeomorph.extend_symm_preimage_inter_range_eventuallyEq
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
M : Type u_3
H : Type u_4
E' : Type u_5
M' : Type u_6
H' : Type u_7
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : TopologicalSpace H
inst✝⁴ : TopologicalSpace M
f f' : PartialHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
inst✝¹ : TopologicalSpace H'
inst✝ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
s✝ t s : Set M
x : M
hs : s ⊆ f.source
hx : x ∈ f.source
⊢ ↑(f.extend I).symm ⁻¹' s ∩ range ↑I =ᶠ[𝓝 (↑(f.extend I) x)] ↑(f.extend I) '' s
state_after: no goals
tactic: rw [← nhdsWithin_eq_iff_eventuallyEq, ← map_extend_nhdsWithin _ _ hx,
    map_extend_nhdsWithin_eq_image_of_subset _ _ hx hs]
Theorem: Tactic.NormNum.int_not_isCoprime_helper
File: Mathlib/Tactic/NormNum/IsCoprime.lean

Proof steps:
state_before: x y : ℤ
d : ℕ
hd : x.gcd y = d
h : d.beq 1 = false
⊢ ¬IsCoprime x y
state_after: x y : ℤ
d : ℕ
hd : x.gcd y = d
h : d.beq 1 = false
⊢ ¬d = 1
tactic: rw [Int.isCoprime_iff_gcd_eq_one, hd]
state_before: x y : ℤ
d : ℕ
hd : x.gcd y = d
h : d.beq 1 = false
⊢ ¬d = 1
state_after: no goals
tactic: exact Nat.ne_of_beq_eq_false h
Theorem: RingQuot.eq_lift_comp_mkRingHom
File: Mathlib/Algebra/RingQuot.lean

Proof steps:
state_before: R : Type uR
inst✝⁴ : Semiring R
S : Type uS
inst✝³ : CommSemiring S
T : Type uT
A : Type uA
inst✝² : Semiring A
inst✝¹ : Algebra S A
r✝ : R → R → Prop
inst✝ : Semiring T
r : R → R → Prop
f : RingQuot r →+* T
⊢ f = lift ⟨f.comp (mkRingHom r), ⋯⟩
state_after: R : Type uR
inst✝⁴ : Semiring R
S : Type uS
inst✝³ : CommSemiring S
T : Type uT
A : Type uA
inst✝² : Semiring A
inst✝¹ : Algebra S A
r✝ : R → R → Prop
inst✝ : Semiring T
r : R → R → Prop
f : RingQuot r →+* T
⊢ lift (lift.symm f) = lift ⟨f.comp (mkRingHom r), ⋯⟩
tactic: conv_lhs => rw [← lift.apply_symm_apply f]
state_before: R : Type uR
inst✝⁴ : Semiring R
S : Type uS
inst✝³ : CommSemiring S
T : Type uT
A : Type uA
inst✝² : Semiring A
inst✝¹ : Algebra S A
r✝ : R → R → Prop
inst✝ : Semiring T
r : R → R → Prop
f : RingQuot r →+* T
⊢ lift (lift.symm f) = lift ⟨f.comp (mkRingHom r), ⋯⟩
state_after: R : Type uR
inst✝⁴ : Semiring R
S : Type uS
inst✝³ : CommSemiring S
T : Type uT
A : Type uA
inst✝² : Semiring A
inst✝¹ : Algebra S A
r✝ : R → R → Prop
inst✝ : Semiring T
r : R → R → Prop
f : RingQuot r →+* T
⊢ { toFun := fun f => preLift ⋯, invFun := fun F => ⟨F.comp (mkRingHom r), ⋯⟩, left_inv := ⋯, right_inv := ⋯ }
      ({ toFun := fun f => preLift ⋯, invFun := fun F => ⟨F.comp (mkRingHom r), ⋯⟩, left_inv := ⋯, right_inv := ⋯ }.symm
        f) =
    { toFun := fun f => preLift ⋯, invFun := fun F => ⟨F.comp (mkRingHom r), ⋯⟩, left_inv := ⋯, right_inv := ⋯ }
      ⟨f.comp (mkRingHom r), ⋯⟩
tactic: rw [lift_def]
state_before: R : Type uR
inst✝⁴ : Semiring R
S : Type uS
inst✝³ : CommSemiring S
T : Type uT
A : Type uA
inst✝² : Semiring A
inst✝¹ : Algebra S A
r✝ : R → R → Prop
inst✝ : Semiring T
r : R → R → Prop
f : RingQuot r →+* T
⊢ { toFun := fun f => preLift ⋯, invFun := fun F => ⟨F.comp (mkRingHom r), ⋯⟩, left_inv := ⋯, right_inv := ⋯ }
      ({ toFun := fun f => preLift ⋯, invFun := fun F => ⟨F.comp (mkRingHom r), ⋯⟩, left_inv := ⋯, right_inv := ⋯ }.symm
        f) =
    { toFun := fun f => preLift ⋯, invFun := fun F => ⟨F.comp (mkRingHom r), ⋯⟩, left_inv := ⋯, right_inv := ⋯ }
      ⟨f.comp (mkRingHom r), ⋯⟩
state_after: no goals
tactic: rfl
Theorem: MeasureTheory.Measure.InnerRegularWRT.measure_eq_iSup
File: Mathlib/MeasureTheory/Measure/Regular.lean

Proof steps:
state_before: α : Type u_1
m : MeasurableSpace α
μ : Measure α
p q : Set α → Prop
U : Set α
ε : ℝ≥0∞
H : μ.InnerRegularWRT p q
hU : q U
⊢ μ U = ⨆ K, ⨆ (_ : K ⊆ U), ⨆ (_ : p K), μ K
state_after: α : Type u_1
m : MeasurableSpace α
μ : Measure α
p q : Set α → Prop
U : Set α
ε : ℝ≥0∞
H : μ.InnerRegularWRT p q
hU : q U
r : ℝ≥0∞
hr : r < μ U
⊢ r < ⨆ K, ⨆ (_ : K ⊆ U), ⨆ (_ : p K), μ K
tactic: refine
    le_antisymm (le_of_forall_lt fun r hr => ?_) (iSup₂_le fun K hK => iSup_le fun _ => μ.mono hK)
state_before: α : Type u_1
m : MeasurableSpace α
μ : Measure α
p q : Set α → Prop
U : Set α
ε : ℝ≥0∞
H : μ.InnerRegularWRT p q
hU : q U
r : ℝ≥0∞
hr : r < μ U
⊢ r < ⨆ K, ⨆ (_ : K ⊆ U), ⨆ (_ : p K), μ K
state_after: no goals
tactic: simpa only [lt_iSup_iff, exists_prop] using H hU r hr
Theorem: HasStrictDerivAt.clog
File: Mathlib/Analysis/SpecialFunctions/Complex/LogDeriv.lean

Proof steps:
state_before: α : Type u_1
inst✝² : TopologicalSpace α
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → ℂ
f' x : ℂ
h₁ : HasStrictDerivAt f f' x
h₂ : f x ∈ slitPlane
⊢ HasStrictDerivAt (fun t => log (f t)) (f' / f x) x
state_after: α : Type u_1
inst✝² : TopologicalSpace α
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → ℂ
f' x : ℂ
h₁ : HasStrictDerivAt f f' x
h₂ : f x ∈ slitPlane
⊢ HasStrictDerivAt (fun t => log (f t)) ((f x)⁻¹ * f') x
tactic: rw [div_eq_inv_mul]
state_before: α : Type u_1
inst✝² : TopologicalSpace α
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → ℂ
f' x : ℂ
h₁ : HasStrictDerivAt f f' x
h₂ : f x ∈ slitPlane
⊢ HasStrictDerivAt (fun t => log (f t)) ((f x)⁻¹ * f') x
state_after: no goals
tactic: exact (hasStrictDerivAt_log h₂).comp x h₁