ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: LinearIndependent.image_subtype
File: Mathlib/LinearAlgebra/LinearIndependent.lean

Proof steps:
state_before: ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
v : ι → M
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M'
inst✝³ : AddCommGroup M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
s : Set M
f : M →ₗ[R] M'
hs : LinearIndependent R fun (x : ↑s) => ↑x
hf_inj : Disjoint (span R s) (ker f)
⊢ LinearIndependent R fun (x : ↑(⇑f '' s)) => ↑x
state_after: ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
v : ι → M
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M'
inst✝³ : AddCommGroup M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
s : Set M
f : M →ₗ[R] M'
hs : LinearIndependent R fun (x : ↑s) => ↑x
hf_inj : Disjoint (span R (Set.range Subtype.val)) (ker f)
⊢ LinearIndependent R fun (x : ↑(⇑f '' s)) => ↑x
tactic: rw [← Subtype.range_coe (s := s)] at hf_inj
state_before: ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
v : ι → M
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M'
inst✝³ : AddCommGroup M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
s : Set M
f : M →ₗ[R] M'
hs : LinearIndependent R fun (x : ↑s) => ↑x
hf_inj : Disjoint (span R (Set.range Subtype.val)) (ker f)
⊢ LinearIndependent R fun (x : ↑(⇑f '' s)) => ↑x
state_after: ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
v : ι → M
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M'
inst✝³ : AddCommGroup M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
s : Set M
f : M →ₗ[R] M'
hs : LinearIndependent R fun (x : ↑s) => ↑x
hf_inj : Disjoint (span R (Set.range Subtype.val)) (ker f)
⊢ Set.range (⇑f ∘ fun x => ↑x) = ⇑f '' s
tactic: refine (hs.map hf_inj).to_subtype_range' ?_
state_before: ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
v : ι → M
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M'
inst✝³ : AddCommGroup M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
s : Set M
f : M →ₗ[R] M'
hs : LinearIndependent R fun (x : ↑s) => ↑x
hf_inj : Disjoint (span R (Set.range Subtype.val)) (ker f)
⊢ Set.range (⇑f ∘ fun x => ↑x) = ⇑f '' s
state_after: no goals
tactic: simp [Set.range_comp f]
Theorem: UniqueAdd.of_addOpposite
File: Mathlib/Algebra/Group/UniqueProds.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
h : UniqueMul (map { toFun := op, inj' := ⋯ } B) (map { toFun := op, inj' := ⋯ } A) (op b0) (op a0)
a b : G
aA : a ∈ A
bB : b ∈ B
ab : a * b = a0 * b0
⊢ a = a0 ∧ b = b0
state_after: no goals
tactic: simpa [and_comm] using h (mem_map_of_mem _ bB) (mem_map_of_mem _ aA) (congr_arg op ab)
Theorem: Submodule.le_pow_toAddSubmonoid
File: Mathlib/Algebra/Algebra/Operations.lean

Proof steps:
state_before: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M N P Q : Submodule R A
m n✝ : A
n : ℕ
⊢ M.toAddSubmonoid ^ n ≤ (M ^ n).toAddSubmonoid
state_after: case inl
ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M N P Q : Submodule R A
m n : A
⊢ M.toAddSubmonoid ^ 0 ≤ (M ^ 0).toAddSubmonoid

case inr
ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M N P Q : Submodule R A
m n✝ : A
n : ℕ
hn : n ≠ 0
⊢ M.toAddSubmonoid ^ n ≤ (M ^ n).toAddSubmonoid
tactic: obtain rfl | hn := Decidable.eq_or_ne n 0
Theorem: NNRat.divNat_zero
File: Mathlib/Data/NNRat/Defs.lean

Proof steps:
state_before: p q : ℚ≥0
n₁ n₂ d₁ d₂ d n : ℕ
⊢ divNat n 0 = 0
state_after: p q : ℚ≥0
n₁ n₂ d₁ d₂ d n : ℕ
⊢ ⟨0, ⋯⟩ = 0
tactic: simp [divNat]
state_before: p q : ℚ≥0
n₁ n₂ d₁ d₂ d n : ℕ
⊢ ⟨0, ⋯⟩ = 0
state_after: no goals
tactic: rfl
Theorem: MeasureTheory.SimpleFunc.tsum_eapproxDiff
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : MeasurableSpace α
K : Type u_5
f : α → ℝ≥0∞
hf : Measurable f
a : α
⊢ ∑' (n : ℕ), ↑(↑(eapproxDiff f n) a) = f a
state_after: no goals
tactic: simp_rw [ENNReal.tsum_eq_iSup_nat' (tendsto_add_atTop_nat 1), sum_eapproxDiff,
    iSup_eapprox_apply f hf a]
Theorem: HolorIndex.drop_take
File: Mathlib/Data/Holor.lean

Proof steps:
state_before: ds₁ ds₂ ds₃ is : List ℕ
h : Forall₂ (fun x x_1 => x < x_1) is (ds₁ ++ ds₂ ++ ds₃)
⊢ ↑(assocRight ⟨is, h⟩).drop.take = ↑(take ⟨is, h⟩).drop
state_after: no goals
tactic: simp [assocRight, take, drop, cast_type, List.drop_take]
Theorem: List.reduceOption_length_lt_iff
File: Mathlib/Data/List/ReduceOption.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l : List (Option α)
⊢ l.reduceOption.length < l.length ↔ none ∈ l
state_after: α : Type u_1
β : Type u_2
l : List (Option α)
⊢ (¬∀ (x : Option α), x ∈ l → x.isSome = true) ↔ none ∈ l
tactic: rw [Nat.lt_iff_le_and_ne, and_iff_right (reduceOption_length_le l), Ne,
    reduceOption_length_eq_iff]
state_before: α : Type u_1
β : Type u_2
l : List (Option α)
⊢ (¬∀ (x : Option α), x ∈ l → x.isSome = true) ↔ none ∈ l
state_after: case cons
α : Type u_1
β : Type u_2
head✝ : Option α
tail✝ : List (Option α)
tail_ih✝ : (¬∀ (x : Option α), x ∈ tail✝ → x.isSome = true) ↔ none ∈ tail✝
⊢ head✝.isSome = true → none ∈ tail✝ ↔ none = head✝ ∨ none ∈ tail✝
tactic: induction l <;> simp
state_before: case cons
α : Type u_1
β : Type u_2
head✝ : Option α
tail✝ : List (Option α)
tail_ih✝ : (¬∀ (x : Option α), x ∈ tail✝ → x.isSome = true) ↔ none ∈ tail✝
⊢ head✝.isSome = true → none ∈ tail✝ ↔ none = head✝ ∨ none ∈ tail✝
state_after: no goals
tactic: rw [@eq_comm _ none, ← Option.not_isSome_iff_eq_none, Decidable.imp_iff_not_or]
Theorem: Rat.mkRat_pow
File: Mathlib/Algebra/Ring/Rat.lean

Proof steps:
state_before: num den n : ℕ
⊢ mkRat (↑num) den ^ n = mkRat (↑num ^ n) (den ^ n)
state_after: no goals
tactic: rw [mkRat_eq_divInt, mkRat_eq_divInt, divInt_pow, Int.natCast_pow]
Theorem: Ioc_subset_closure_interior
File: Mathlib/Topology/Order/DenselyOrdered.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a✝ b✝ : α
s : Set α
a b : α
⊢ Ioc a b ⊆ closure (interior (Ioc a b))
state_after: case inl
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a✝ b : α
s : Set α
a : α
⊢ Ioc a a ⊆ closure (interior (Ioc a a))

case inr
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a✝ b✝ : α
s : Set α
a b : α
h : a ≠ b
⊢ Ioc a b ⊆ closure (interior (Ioc a b))
tactic: rcases eq_or_ne a b with (rfl | h)
Theorem: Complex.ofReal_sin_ofReal_re
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x✝ y : ℂ
x : ℝ
⊢ (starRingEnd ℂ) (sin ↑x) = sin ↑x
state_after: no goals
tactic: rw [← sin_conj, conj_ofReal]
Theorem: PartialEquiv.mem_symm_trans_source
File: Mathlib/Logic/Equiv/PartialEquiv.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e : PartialEquiv α β
e'✝ : PartialEquiv β γ
e' : PartialEquiv α γ
x : α
he : x ∈ e.source
he' : x ∈ e'.source
⊢ ↑e x ∈ ↑e.symm.symm.symm ⁻¹' e'.source
state_after: no goals
tactic: rwa [mem_preimage, PartialEquiv.symm_symm, e.left_inv he]
Theorem: uniformity_eq_uniformity_interior
File: Mathlib/Topology/UniformSpace/Basic.lean

Proof steps:
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
d : Set (α × α)
hd : d ∈ 𝓤 α
⊢ 𝓤 α ≤ (𝓟 ∘ interior) d
state_after: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
d : Set (α × α)
hd : d ∈ 𝓤 α
s : Set (α × α)
hs : s ∈ 𝓤 α
hs_comp : s ○ (s ○ s) ⊆ d
⊢ 𝓤 α ≤ (𝓟 ∘ interior) d
tactic: let ⟨s, hs, hs_comp⟩ := comp3_mem_uniformity hd
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
d : Set (α × α)
hd : d ∈ 𝓤 α
s : Set (α × α)
hs : s ∈ 𝓤 α
hs_comp : s ○ (s ○ s) ⊆ d
⊢ 𝓤 α ≤ (𝓟 ∘ interior) d
state_after: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
d : Set (α × α)
hd : d ∈ 𝓤 α
s : Set (α × α)
hs : s ∈ 𝓤 α
hs_comp : s ○ (s ○ s) ⊆ d
t : Set (α × α)
ht : IsOpen t
hst : s ⊆ t
ht_comp : t ⊆ {p | ∃ x y, (p.1, x) ∈ s ∧ (x, y) ∈ s ∧ (y, p.2) ∈ s}
⊢ 𝓤 α ≤ (𝓟 ∘ interior) d
tactic: let ⟨t, ht, hst, ht_comp⟩ := nhdset_of_mem_uniformity s hs
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
d : Set (α × α)
hd : d ∈ 𝓤 α
s : Set (α × α)
hs : s ∈ 𝓤 α
hs_comp : s ○ (s ○ s) ⊆ d
t : Set (α × α)
ht : IsOpen t
hst : s ⊆ t
ht_comp : t ⊆ {p | ∃ x y, (p.1, x) ∈ s ∧ (x, y) ∈ s ∧ (y, p.2) ∈ s}
⊢ 𝓤 α ≤ (𝓟 ∘ interior) d
state_after: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
d : Set (α × α)
hd : d ∈ 𝓤 α
s : Set (α × α)
hs : s ∈ 𝓤 α
hs_comp : s ○ (s ○ s) ⊆ d
t : Set (α × α)
ht : IsOpen t
hst : s ⊆ t
ht_comp : t ⊆ {p | ∃ x y, (p.1, x) ∈ s ∧ (x, y) ∈ s ∧ (y, p.2) ∈ s}
this : s ⊆ interior d
⊢ 𝓤 α ≤ (𝓟 ∘ interior) d
tactic: have : s ⊆ interior d :=
        calc
          s ⊆ t := hst
          _ ⊆ interior d :=
            ht.subset_interior_iff.mpr fun x (hx : x ∈ t) =>
              let ⟨x, y, h₁, h₂, h₃⟩ := ht_comp hx
              hs_comp ⟨x, h₁, y, h₂, h₃⟩
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
d : Set (α × α)
hd : d ∈ 𝓤 α
s : Set (α × α)
hs : s ∈ 𝓤 α
hs_comp : s ○ (s ○ s) ⊆ d
t : Set (α × α)
ht : IsOpen t
hst : s ⊆ t
ht_comp : t ⊆ {p | ∃ x y, (p.1, x) ∈ s ∧ (x, y) ∈ s ∧ (y, p.2) ∈ s}
this : s ⊆ interior d
⊢ 𝓤 α ≤ (𝓟 ∘ interior) d
state_after: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
d : Set (α × α)
hd : d ∈ 𝓤 α
s : Set (α × α)
hs : s ∈ 𝓤 α
hs_comp : s ○ (s ○ s) ⊆ d
t : Set (α × α)
ht : IsOpen t
hst : s ⊆ t
ht_comp : t ⊆ {p | ∃ x y, (p.1, x) ∈ s ∧ (x, y) ∈ s ∧ (y, p.2) ∈ s}
this✝ : s ⊆ interior d
this : interior d ∈ 𝓤 α
⊢ 𝓤 α ≤ (𝓟 ∘ interior) d
tactic: have : interior d ∈ 𝓤 α := by filter_upwards [hs] using this
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
d : Set (α × α)
hd : d ∈ 𝓤 α
s : Set (α × α)
hs : s ∈ 𝓤 α
hs_comp : s ○ (s ○ s) ⊆ d
t : Set (α × α)
ht : IsOpen t
hst : s ⊆ t
ht_comp : t ⊆ {p | ∃ x y, (p.1, x) ∈ s ∧ (x, y) ∈ s ∧ (y, p.2) ∈ s}
this✝ : s ⊆ interior d
this : interior d ∈ 𝓤 α
⊢ 𝓤 α ≤ (𝓟 ∘ interior) d
state_after: no goals
tactic: simp [this]
Theorem: EReal.exp_eq_top_iff
File: Mathlib/Analysis/SpecialFunctions/Log/ERealExp.lean

Proof steps:
state_before: x : EReal
⊢ x.exp = ⊤ ↔ x = ⊤
state_after: no goals
tactic: induction x <;> simp
Theorem: IsRadical.of_dvd
File: Mathlib/RingTheory/Nilpotent/Basic.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
x✝ y✝ : R
inst✝ : CancelCommMonoidWithZero R
x y : R
hy : IsRadical y
h0 : y ≠ 0
hxy : x ∣ y
⊢ ∀ (x_1 : R), x ∣ x_1 ^ 2 → x ∣ x_1
state_after: case intro
R : Type u_1
S : Type u_2
x✝ y : R
inst✝ : CancelCommMonoidWithZero R
x z : R
hy : IsRadical (x * z)
h0 : x * z ≠ 0
⊢ ∀ (x_1 : R), x ∣ x_1 ^ 2 → x ∣ x_1
tactic: obtain ⟨z, rfl⟩ := hxy
state_before: case intro
R : Type u_1
S : Type u_2
x✝ y : R
inst✝ : CancelCommMonoidWithZero R
x z : R
hy : IsRadical (x * z)
h0 : x * z ≠ 0
⊢ ∀ (x_1 : R), x ∣ x_1 ^ 2 → x ∣ x_1
state_after: case intro
R : Type u_1
S : Type u_2
x✝ y : R
inst✝ : CancelCommMonoidWithZero R
x z : R
hy : IsRadical (x * z)
h0 : x * z ≠ 0
w : R
dvd : x ∣ w ^ 2
⊢ x * z ∣ (w * z) ^ 2
tactic: refine fun w dvd ↦ ((mul_dvd_mul_iff_right <| right_ne_zero_of_mul h0).mp <| hy 2 _ ?_)
state_before: case intro
R : Type u_1
S : Type u_2
x✝ y : R
inst✝ : CancelCommMonoidWithZero R
x z : R
hy : IsRadical (x * z)
h0 : x * z ≠ 0
w : R
dvd : x ∣ w ^ 2
⊢ x * z ∣ (w * z) ^ 2
state_after: case intro
R : Type u_1
S : Type u_2
x✝ y : R
inst✝ : CancelCommMonoidWithZero R
x z : R
hy : IsRadical (x * z)
h0 : x * z ≠ 0
w : R
dvd : x ∣ w ^ 2
⊢ x * z ∣ w ^ 2 * (z * z)
tactic: rw [mul_pow, sq z]
state_before: case intro
R : Type u_1
S : Type u_2
x✝ y : R
inst✝ : CancelCommMonoidWithZero R
x z : R
hy : IsRadical (x * z)
h0 : x * z ≠ 0
w : R
dvd : x ∣ w ^ 2
⊢ x * z ∣ w ^ 2 * (z * z)
state_after: no goals
tactic: exact mul_dvd_mul dvd (dvd_mul_left z z)
Theorem: Set.image_update_Ico
File: Mathlib/Order/Interval/Set/Pi.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → PartialOrder (α i)
f : (i : ι) → α i
i : ι
a b : α i
⊢ update f i '' Ico a b = Ico (update f i a) (update f i b)
state_after: no goals
tactic: rw [← Icc_diff_right, ← Icc_diff_right, image_diff (update_injective _ _), image_singleton,
    image_update_Icc]
Theorem: isLeast_csInf
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝¹ : ConditionallyCompleteLinearOrder α
s t : Set α
a b : α
inst✝ : IsWellOrder α fun x x_1 => x < x_1
hs : s.Nonempty
⊢ IsLeast s (sInf s)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝¹ : ConditionallyCompleteLinearOrder α
s t : Set α
a b : α
inst✝ : IsWellOrder α fun x x_1 => x < x_1
hs : s.Nonempty
⊢ IsLeast s (argminOn id ⋯ s hs)
tactic: rw [sInf_eq_argmin_on hs]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝¹ : ConditionallyCompleteLinearOrder α
s t : Set α
a b : α
inst✝ : IsWellOrder α fun x x_1 => x < x_1
hs : s.Nonempty
⊢ IsLeast s (argminOn id ⋯ s hs)
state_after: no goals
tactic: exact ⟨argminOn_mem _ _ _ _, fun a ha => argminOn_le id _ _ ha⟩
Theorem: Finset.Nontrivial.sdiff_singleton_nonempty
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 c : α
s : Finset α
hS : s.Nontrivial
⊢ (s \ {c}).Nonempty
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ t u v : Finset α
a b c : α
s : Finset α
hS : s.Nontrivial
⊢ ¬(s = ∅ ∨ s = {c})
tactic: rw [Finset.sdiff_nonempty, Finset.subset_singleton_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ t u v : Finset α
a b c : α
s : Finset α
hS : s.Nontrivial
⊢ ¬(s = ∅ ∨ s = {c})
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ t u v : Finset α
a b c : α
s : Finset α
hS : s.Nontrivial
⊢ s ≠ ∅ ∧ s ≠ {c}
tactic: push_neg
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ t u v : Finset α
a b c : α
s : Finset α
hS : s.Nontrivial
⊢ s ≠ ∅ ∧ s ≠ {c}
state_after: no goals
tactic: exact ⟨by rintro rfl; exact Finset.not_nontrivial_empty hS, hS.ne_singleton⟩
Theorem: smoothSheafCommRing.isUnit_stalk_iff
File: Mathlib/Geometry/Manifold/Sheaf/LocallyRingedSpace.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : CompleteSpace 𝕜
EM : Type u_1
inst✝⁴ : NormedAddCommGroup EM
inst✝³ : NormedSpace 𝕜 EM
HM : Type u_2
inst✝² : TopologicalSpace HM
IM : ModelWithCorners 𝕜 EM HM
M : Type u
inst✝¹ : TopologicalSpace M
inst✝ : ChartedSpace HM M
x : M
f : ↑((smoothSheafCommRing IM 𝓘(𝕜, 𝕜) M 𝕜).presheaf.stalk x)
⊢ IsUnit f ↔ f ∉ RingHom.ker (eval IM 𝓘(𝕜, 𝕜) M 𝕜 x)
state_after: case mp
𝕜 : Type u
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : CompleteSpace 𝕜
EM : Type u_1
inst✝⁴ : NormedAddCommGroup EM
inst✝³ : NormedSpace 𝕜 EM
HM : Type u_2
inst✝² : TopologicalSpace HM
IM : ModelWithCorners 𝕜 EM HM
M : Type u
inst✝¹ : TopologicalSpace M
inst✝ : ChartedSpace HM M
x : M
f : ↑((smoothSheafCommRing IM 𝓘(𝕜, 𝕜) M 𝕜).presheaf.stalk x)
⊢ IsUnit f → f ∉ RingHom.ker (eval IM 𝓘(𝕜, 𝕜) M 𝕜 x)

case mpr
𝕜 : Type u
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : CompleteSpace 𝕜
EM : Type u_1
inst✝⁴ : NormedAddCommGroup EM
inst✝³ : NormedSpace 𝕜 EM
HM : Type u_2
inst✝² : TopologicalSpace HM
IM : ModelWithCorners 𝕜 EM HM
M : Type u
inst✝¹ : TopologicalSpace M
inst✝ : ChartedSpace HM M
x : M
f : ↑((smoothSheafCommRing IM 𝓘(𝕜, 𝕜) M 𝕜).presheaf.stalk x)
⊢ f ∉ RingHom.ker (eval IM 𝓘(𝕜, 𝕜) M 𝕜 x) → IsUnit f
tactic: constructor
Theorem: ZMod.ker_intCastRingHom
File: Mathlib/RingTheory/ZMod.lean

Proof steps:
state_before: n : ℕ
⊢ RingHom.ker (Int.castRingHom (ZMod n)) = Ideal.span {↑n}
state_after: case h
n : ℕ
x✝ : ℤ
⊢ x✝ ∈ RingHom.ker (Int.castRingHom (ZMod n)) ↔ x✝ ∈ Ideal.span {↑n}
tactic: ext
state_before: case h
n : ℕ
x✝ : ℤ
⊢ x✝ ∈ RingHom.ker (Int.castRingHom (ZMod n)) ↔ x✝ ∈ Ideal.span {↑n}
state_after: no goals
tactic: rw [Ideal.mem_span_singleton, RingHom.mem_ker, Int.coe_castRingHom,
    ZMod.intCast_zmod_eq_zero_iff_dvd]
Theorem: Nat.bit_add'
File: Mathlib/Data/Nat/Bits.lean

Proof steps:
state_before: m n x✝¹ x✝ : ℕ
⊢ bit true (x✝¹ + x✝) = bit true x✝¹ + bit false x✝
state_after: m n x✝¹ x✝ : ℕ
⊢ 2 * (x✝¹ + x✝) + 1 = 2 * x✝¹ + 1 + 2 * x✝
tactic: dsimp [bit]
state_before: m n x✝¹ x✝ : ℕ
⊢ 2 * (x✝¹ + x✝) + 1 = 2 * x✝¹ + 1 + 2 * x✝
state_after: no goals
tactic: omega
state_before: m n x✝¹ x✝ : ℕ
⊢ bit false (x✝¹ + x✝) = bit false x✝¹ + bit false x✝
state_after: m n x✝¹ x✝ : ℕ
⊢ 2 * (x✝¹ + x✝) = 2 * x✝¹ + 2 * x✝
tactic: dsimp [bit]
state_before: m n x✝¹ x✝ : ℕ
⊢ 2 * (x✝¹ + x✝) = 2 * x✝¹ + 2 * x✝
state_after: no goals
tactic: omega
Theorem: separatesPoints_continuous_of_t35Space
File: Mathlib/Topology/CompletelyRegular.lean

Proof steps:
state_before: X : Type u
inst✝² : TopologicalSpace X
inst✝¹ : T1Space X
inst✝ : T35Space X
⊢ SeparatesPoints Continuous
state_after: X : Type u
inst✝² : TopologicalSpace X
inst✝¹ : T1Space X
inst✝ : T35Space X
x y : X
x_ne_y : x ≠ y
⊢ ∃ f ∈ Continuous, f x ≠ f y
tactic: intro x y x_ne_y
state_before: X : Type u
inst✝² : TopologicalSpace X
inst✝¹ : T1Space X
inst✝ : T35Space X
x y : X
x_ne_y : x ≠ y
⊢ ∃ f ∈ Continuous, f x ≠ f y
state_after: case intro.intro.intro
X : Type u
inst✝² : TopologicalSpace X
inst✝¹ : T1Space X
inst✝ : T35Space X
x y : X
x_ne_y : x ≠ y
f : X → ↑I
f_cont : Continuous f
f_zero : f x = 0
f_one : EqOn f 1 {y}
⊢ ∃ f ∈ Continuous, f x ≠ f y
tactic: obtain ⟨f, f_cont, f_zero, f_one⟩ :=
    CompletelyRegularSpace.completely_regular x {y} isClosed_singleton x_ne_y
state_before: case intro.intro.intro
X : Type u
inst✝² : TopologicalSpace X
inst✝¹ : T1Space X
inst✝ : T35Space X
x y : X
x_ne_y : x ≠ y
f : X → ↑I
f_cont : Continuous f
f_zero : f x = 0
f_one : EqOn f 1 {y}
⊢ ∃ f ∈ Continuous, f x ≠ f y
state_after: no goals
tactic: exact ⟨fun x ↦ f x, continuous_subtype_val.comp f_cont, by aesop⟩
Theorem: CancelDenoms.pow_subst
File: Mathlib/Tactic/CancelDenoms/Core.lean

Proof steps:
state_before: α : Type u_1
inst✝ : CommRing α
n e1 t1 k l : α
e2 : ℕ
h1 : n * e1 = t1
h2 : l * n ^ e2 = k
⊢ k * e1 ^ e2 = l * t1 ^ e2
state_after: no goals
tactic: rw [← h2, ← h1, mul_pow, mul_assoc]
Theorem: List.Ico.filter_lt_of_top_le
File: Mathlib/Data/List/Intervals.lean

Proof steps:
state_before: n m l : ℕ
hml : m ≤ l
k : ℕ
hk : k ∈ Ico n m
⊢ decide (k < l) = true
state_after: no goals
tactic: simp only [(lt_of_lt_of_le (mem.1 hk).2 hml), decide_True]
Theorem: Metric.cthickening_closure
File: Mathlib/Topology/MetricSpace/Thickening.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ ε : ℝ
s t : Set α
x : α
⊢ cthickening δ (closure s) = cthickening δ s
state_after: no goals
tactic: simp_rw [cthickening, infEdist_closure]
Theorem: AddUnits.neg_add_cancel_left
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
inst✝ : Monoid α
a✝ b✝ c u a : αˣ
b : α
⊢ ↑a⁻¹ * (↑a * b) = b
state_after: no goals
tactic: rw [← mul_assoc, inv_mul, one_mul]
Theorem: CategoryTheory.Localization.homEquiv_id
File: Mathlib/CategoryTheory/Localization/HomEquiv.lean

Proof steps:
state_before: C : Type u_1
C₁ : Type u_2
C₂ : Type u_3
C₃ : Type u_4
D₁ : Type u_5
D₂ : Type u_6
D₃ : Type u_7
inst✝⁹ : Category.{u_9, u_1} C
inst✝⁸ : Category.{?u.48505, u_2} C₁
inst✝⁷ : Category.{?u.48509, u_3} C₂
inst✝⁶ : Category.{?u.48513, u_4} C₃
inst✝⁵ : Category.{u_10, u_5} D₁
inst✝⁴ : Category.{u_8, u_6} D₂
inst✝³ : Category.{?u.48525, u_7} D₃
W : MorphismProperty C
L₁ : C ⥤ D₁
inst✝² : L₁.IsLocalization W
L₂ : C ⥤ D₂
inst✝¹ : L₂.IsLocalization W
L₃ : C ⥤ D₃
inst✝ : L₃.IsLocalization W
X Y Z : C
⊢ (homEquiv W L₁ L₂) (𝟙 (L₁.obj X)) = 𝟙 (L₂.obj X)
state_after: no goals
tactic: simp [homEquiv_apply]
Theorem: Subspace.dual_finrank_eq
File: Mathlib/LinearAlgebra/Dual.lean

Proof steps:
state_before: K : Type u
V : Type v
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
W : Subspace K V
⊢ finrank K (Module.Dual K V) = finrank K V
state_after: case pos
K : Type u
V : Type v
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
W : Subspace K V
h : FiniteDimensional K V
⊢ finrank K (Module.Dual K V) = finrank K V

case neg
K : Type u
V : Type v
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
W : Subspace K V
h : ¬FiniteDimensional K V
⊢ finrank K (Module.Dual K V) = finrank K V
tactic: by_cases h : FiniteDimensional K V
state_before: case neg
K : Type u
V : Type v
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
W : Subspace K V
h : ¬FiniteDimensional K V
⊢ finrank K (Module.Dual K V) = finrank K V
state_after: case neg
K : Type u
V : Type v
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
W : Subspace K V
h : ¬FiniteDimensional K V
⊢ ∀ (s : Finset V), Basis (↑↑s) K V → False

case neg
K : Type u
V : Type v
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
W : Subspace K V
h : ¬FiniteDimensional K V
⊢ ∀ (s : Finset (Module.Dual K V)), Basis (↑↑s) K (Module.Dual K V) → False
tactic: rw [finrank_eq_zero_of_basis_imp_false, finrank_eq_zero_of_basis_imp_false]
Theorem: map_eq_bot_iff
File: Mathlib/Order/Hom/Bounded.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝⁵ : EquivLike F α β
inst✝⁴ : LE α
inst✝³ : OrderBot α
inst✝² : PartialOrder β
inst✝¹ : OrderBot β
inst✝ : OrderIsoClass F α β
f : F
a : α
⊢ f a = ⊥ ↔ a = ⊥
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝⁵ : EquivLike F α β
inst✝⁴ : LE α
inst✝³ : OrderBot α
inst✝² : PartialOrder β
inst✝¹ : OrderBot β
inst✝ : OrderIsoClass F α β
f : F
a : α
this : BotHomClass F α β := OrderIsoClass.toBotHomClass
⊢ f a = ⊥ ↔ a = ⊥
tactic: letI : BotHomClass F α β := OrderIsoClass.toBotHomClass
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝⁵ : EquivLike F α β
inst✝⁴ : LE α
inst✝³ : OrderBot α
inst✝² : PartialOrder β
inst✝¹ : OrderBot β
inst✝ : OrderIsoClass F α β
f : F
a : α
this : BotHomClass F α β := OrderIsoClass.toBotHomClass
⊢ f a = ⊥ ↔ a = ⊥
state_after: no goals
tactic: rw [← map_bot f, (EquivLike.injective f).eq_iff]
Theorem: max_sub_max_le_max
File: Mathlib/Algebra/Order/Group/MinMax.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b✝ c✝ a b c d : α
⊢ max a b - max c d ≤ max (a - c) (b - d)
state_after: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b✝ c✝ a b c d : α
⊢ a ≤ max (a - c) (b - d) + max c d ∧ b ≤ max (a - c) (b - d) + max c d
tactic: simp only [sub_le_iff_le_add, max_le_iff]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b✝ c✝ a b c d : α
⊢ a ≤ max (a - c) (b - d) + max c d ∧ b ≤ max (a - c) (b - d) + max c d
state_after: case left
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b✝ c✝ a b c d : α
⊢ a ≤ max (a - c) (b - d) + max c d

case right
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b✝ c✝ a b c d : α
⊢ b ≤ max (a - c) (b - d) + max c d
tactic: constructor
Theorem: monovaryOn_inv_right
File: Mathlib/Algebra/Order/Monovary.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : OrderedCommGroup α
inst✝ : OrderedCommGroup β
s : Set ι
f f₁ f₂ : ι → α
g g₁ g₂ : ι → β
⊢ MonovaryOn f g⁻¹ s ↔ AntivaryOn f g s
state_after: no goals
tactic: simpa [MonovaryOn, AntivaryOn] using forall₂_swap