ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: RCLike.exists_norm_eq_mul_self
File: Mathlib/Analysis/RCLike/Basic.lean

Proof steps:
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z x : K
⊢ ∃ c, ‖c‖ = 1 ∧ ↑‖x‖ = c * x
state_after: case inl
K : Type u_1
E : Type u_2
inst✝ : RCLike K
z : K
⊢ ∃ c, ‖c‖ = 1 ∧ ↑‖0‖ = c * 0

case inr
K : Type u_1
E : Type u_2
inst✝ : RCLike K
z x : K
hx : x ≠ 0
⊢ ∃ c, ‖c‖ = 1 ∧ ↑‖x‖ = c * x
tactic: obtain rfl | hx := eq_or_ne x 0
Theorem: DFinsupp.comapDomain_zero
File: Mathlib/Data/DFinsupp/Basic.lean

Proof steps:
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
κ : Type u_1
inst✝ : (i : ι) → Zero (β i)
h : κ → ι
hh : Function.Injective h
⊢ comapDomain h hh 0 = 0
state_after: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
κ : Type u_1
inst✝ : (i : ι) → Zero (β i)
h : κ → ι
hh : Function.Injective h
i✝ : κ
⊢ (comapDomain h hh 0) i✝ = 0 i✝
tactic: ext
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
κ : Type u_1
inst✝ : (i : ι) → Zero (β i)
h : κ → ι
hh : Function.Injective h
i✝ : κ
⊢ (comapDomain h hh 0) i✝ = 0 i✝
state_after: no goals
tactic: rw [zero_apply, comapDomain_apply, zero_apply]
Theorem: MeasureTheory.restrict_compl_sigmaFiniteSet_eq_zero_or_top
File: Mathlib/MeasureTheory/Measure/WithDensityFinite.lean

Proof steps:
state_before: α : Type u_1
mα : MeasurableSpace α
μ✝ : Measure α
s✝ t : Set α
μ : Measure α
inst✝ : SFinite μ
s : Set α
⊢ (μ.restrict μ.sigmaFiniteSetᶜ) s = 0 ∨ (μ.restrict μ.sigmaFiniteSetᶜ) s = ⊤
state_after: α : Type u_1
mα : MeasurableSpace α
μ✝ : Measure α
s✝ t : Set α
μ : Measure α
inst✝ : SFinite μ
s : Set α
⊢ (⊤ • μ.toFinite.restrict μ.sigmaFiniteSetᶜ) s = 0 ∨ (⊤ • μ.toFinite.restrict μ.sigmaFiniteSetᶜ) s = ⊤
tactic: rw [restrict_compl_sigmaFiniteSet]
state_before: α : Type u_1
mα : MeasurableSpace α
μ✝ : Measure α
s✝ t : Set α
μ : Measure α
inst✝ : SFinite μ
s : Set α
⊢ (⊤ • μ.toFinite.restrict μ.sigmaFiniteSetᶜ) s = 0 ∨ (⊤ • μ.toFinite.restrict μ.sigmaFiniteSetᶜ) s = ⊤
state_after: α : Type u_1
mα : MeasurableSpace α
μ✝ : Measure α
s✝ t : Set α
μ : Measure α
inst✝ : SFinite μ
s : Set α
⊢ (μ.toFinite.restrict μ.sigmaFiniteSetᶜ) s = 0 ∨ ⊤ * (μ.toFinite.restrict μ.sigmaFiniteSetᶜ) s = ⊤
tactic: simp only [Measure.coe_smul, Pi.smul_apply, smul_eq_mul, mul_eq_zero, ENNReal.top_ne_zero,
    false_or]
state_before: α : Type u_1
mα : MeasurableSpace α
μ✝ : Measure α
s✝ t : Set α
μ : Measure α
inst✝ : SFinite μ
s : Set α
⊢ (μ.toFinite.restrict μ.sigmaFiniteSetᶜ) s = 0 ∨ ⊤ * (μ.toFinite.restrict μ.sigmaFiniteSetᶜ) s = ⊤
state_after: α : Type u_1
mα : MeasurableSpace α
μ✝ : Measure α
s✝ t : Set α
μ : Measure α
inst✝ : SFinite μ
s : Set α
⊢ μ.toFinite (s ∩ μ.sigmaFiniteSetᶜ) = 0 ∨ ⊤ * μ.toFinite (s ∩ μ.sigmaFiniteSetᶜ) = ⊤
tactic: rw [Measure.restrict_apply' (measurableSet_sigmaFiniteSet μ).compl]
state_before: α : Type u_1
mα : MeasurableSpace α
μ✝ : Measure α
s✝ t : Set α
μ : Measure α
inst✝ : SFinite μ
s : Set α
⊢ μ.toFinite (s ∩ μ.sigmaFiniteSetᶜ) = 0 ∨ ⊤ * μ.toFinite (s ∩ μ.sigmaFiniteSetᶜ) = ⊤
state_after: case pos
α : Type u_1
mα : MeasurableSpace α
μ✝ : Measure α
s✝ t : Set α
μ : Measure α
inst✝ : SFinite μ
s : Set α
h_zero : μ.toFinite (s ∩ μ.sigmaFiniteSetᶜ) = 0
⊢ μ.toFinite (s ∩ μ.sigmaFiniteSetᶜ) = 0 ∨ ⊤ * μ.toFinite (s ∩ μ.sigmaFiniteSetᶜ) = ⊤

case neg
α : Type u_1
mα : MeasurableSpace α
μ✝ : Measure α
s✝ t : Set α
μ : Measure α
inst✝ : SFinite μ
s : Set α
h_zero : ¬μ.toFinite (s ∩ μ.sigmaFiniteSetᶜ) = 0
⊢ μ.toFinite (s ∩ μ.sigmaFiniteSetᶜ) = 0 ∨ ⊤ * μ.toFinite (s ∩ μ.sigmaFiniteSetᶜ) = ⊤
tactic: by_cases h_zero : μ.toFinite (s ∩ μ.sigmaFiniteSetᶜ) = 0
Theorem: Set.image_injective
File: Mathlib/Data/Set/Image.lean

Proof steps:
state_before: α : Type u
β : Type v
f : α → β
⊢ Injective (image f) ↔ Injective f
state_after: α : Type u
β : Type v
f : α → β
h : Injective (image f)
x x' : α
hx : f x = f x'
⊢ x = x'
tactic: refine ⟨fun h x x' hx => ?_, Injective.image_injective⟩
state_before: α : Type u
β : Type v
f : α → β
h : Injective (image f)
x x' : α
hx : f x = f x'
⊢ x = x'
state_after: α : Type u
β : Type v
f : α → β
h : Injective (image f)
x x' : α
hx : f x = f x'
⊢ {x} = {x'}
tactic: rw [← singleton_eq_singleton_iff]
state_before: α : Type u
β : Type v
f : α → β
h : Injective (image f)
x x' : α
hx : f x = f x'
⊢ {x} = {x'}
state_after: case a
α : Type u
β : Type v
f : α → β
h : Injective (image f)
x x' : α
hx : f x = f x'
⊢ f '' {x} = f '' {x'}
tactic: apply h
state_before: case a
α : Type u
β : Type v
f : α → β
h : Injective (image f)
x x' : α
hx : f x = f x'
⊢ f '' {x} = f '' {x'}
state_after: no goals
tactic: rw [image_singleton, image_singleton, hx]
Theorem: ContDiff.pow
File: Mathlib/Analysis/Calculus/ContDiff/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁵ : NormedAddCommGroup D
inst✝¹⁴ : NormedSpace 𝕜 D
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
𝔸 : Type u_3
𝔸' : Type u_4
ι : Type u_5
𝕜' : Type u_6
inst✝⁵ : NormedRing 𝔸
inst✝⁴ : NormedAlgebra 𝕜 𝔸
inst✝³ : NormedCommRing 𝔸'
inst✝² : NormedAlgebra 𝕜 𝔸'
inst✝¹ : NormedField 𝕜'
inst✝ : NormedAlgebra 𝕜 𝕜'
f : E → 𝔸
hf : ContDiff 𝕜 n f
⊢ ContDiff 𝕜 n fun x => f x ^ 0
state_after: no goals
tactic: simpa using contDiff_const
state_before: 𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁵ : NormedAddCommGroup D
inst✝¹⁴ : NormedSpace 𝕜 D
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
m✝ n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
𝔸 : Type u_3
𝔸' : Type u_4
ι : Type u_5
𝕜' : Type u_6
inst✝⁵ : NormedRing 𝔸
inst✝⁴ : NormedAlgebra 𝕜 𝔸
inst✝³ : NormedCommRing 𝔸'
inst✝² : NormedAlgebra 𝕜 𝔸'
inst✝¹ : NormedField 𝕜'
inst✝ : NormedAlgebra 𝕜 𝕜'
f : E → 𝔸
hf : ContDiff 𝕜 n f
m : ℕ
⊢ ContDiff 𝕜 n fun x => f x ^ (m + 1)
state_after: no goals
tactic: simpa [pow_succ] using (hf.pow m).mul hf
Theorem: tsum_eq_single
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f✝ g : β → α
a a₁ a₂ : α
f : β → α
b : β
hf : ∀ (b' : β), b' ≠ b → f b' = 1
⊢ ∏' (b : β), f b = f b
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f✝ g : β → α
a a₁ a₂ : α
f : β → α
b : β
hf : ∀ (b' : β), b' ≠ b → f b' = 1
⊢ ∀ b_1 ∉ {b}, f b_1 = 1
tactic: rw [tprod_eq_prod (s := {b}), prod_singleton]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f✝ g : β → α
a a₁ a₂ : α
f : β → α
b : β
hf : ∀ (b' : β), b' ≠ b → f b' = 1
⊢ ∀ b_1 ∉ {b}, f b_1 = 1
state_after: no goals
tactic: exact fun b' hb' ↦ hf b' (by simpa using hb')
Theorem: Lagrange.degree_basis
File: Mathlib/LinearAlgebra/Lagrange.lean

Proof steps:
state_before: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s : Finset ι
v : ι → F
i j : ι
hvs : Set.InjOn v ↑s
hi : i ∈ s
⊢ (Lagrange.basis s v i).degree = ↑(s.card - 1)
state_after: no goals
tactic: rw [degree_eq_natDegree (basis_ne_zero hvs hi), natDegree_basis hvs hi]
Theorem: Padic.valuation_p
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
⊢ (↑p).valuation = 1
state_after: p : ℕ
hp : Fact (Nat.Prime p)
h : 1 < ↑p
⊢ (↑p).valuation = 1
tactic: have h : (1 : ℝ) < p := mod_cast (Fact.out : p.Prime).one_lt
state_before: p : ℕ
hp : Fact (Nat.Prime p)
h : 1 < ↑p
⊢ (↑p).valuation = 1
state_after: case refine_1
p : ℕ
hp : Fact (Nat.Prime p)
h : 1 < ↑p
⊢ ↑p ≠ 0

case refine_2
p : ℕ
hp : Fact (Nat.Prime p)
h : 1 < ↑p
⊢ ‖↑p‖ = ↑p ^ (-1)
tactic: refine neg_injective ((zpow_strictMono h).injective <| (norm_eq_pow_val ?_).symm.trans ?_)
Theorem: Nat.mem_primeFactors
File: Mathlib/Data/Nat/PrimeFin.lean

Proof steps:
state_before: a b k m n p : ℕ
⊢ p ∈ n.primeFactors ↔ Prime p ∧ p ∣ n ∧ n ≠ 0
state_after: no goals
tactic: simp_rw [← toFinset_factors, List.mem_toFinset, mem_primeFactorsList']
Theorem: Complex.mk_eq_add_mul_I
File: Mathlib/Data/Complex/Basic.lean

Proof steps:
state_before: a b : ℝ
⊢ { re := a, im := b }.re = (↑a + ↑b * I).re ∧ { re := a, im := b }.im = (↑a + ↑b * I).im
state_after: no goals
tactic: simp [ofReal']
Theorem: CategoryTheory.isoClosure_eq_self
File: Mathlib/CategoryTheory/ClosedUnderIsomorphisms.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
P Q : C → Prop
inst✝ : ClosedUnderIsomorphisms P
⊢ isoClosure P = P
state_after: case a
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
P Q : C → Prop
inst✝ : ClosedUnderIsomorphisms P
⊢ isoClosure P ≤ P

case a
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
P Q : C → Prop
inst✝ : ClosedUnderIsomorphisms P
⊢ P ≤ isoClosure P
tactic: apply le_antisymm
Theorem: Finset.union_right_comm
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ s₁ s₂ t✝ t₁ t₂ u✝ v : Finset α
a b : α
s t u : Finset α
x : α
⊢ x ∈ s ∪ t ∪ u ↔ x ∈ s ∪ u ∪ t
state_after: no goals
tactic: simp only [mem_union, or_assoc, @or_comm (x ∈ t)]
Theorem: Finsupp.sumFinsuppAddEquivProdFinsupp_symm_apply
File: Mathlib/Data/Finsupp/Basic.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✝ : AddMonoid M
α : Type u_13
β : Type u_14
⊢ ∀ (x y : α ⊕ β →₀ M), __src✝.toFun (x + y) = __src✝.toFun x + __src✝.toFun y
state_after: α✝ : 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✝ : AddMonoid M
α : Type u_13
β : Type u_14
x✝ y✝ : α ⊕ β →₀ M
⊢ __src✝.toFun (x✝ + y✝) = __src✝.toFun x✝ + __src✝.toFun y✝
tactic: intros
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✝ : AddMonoid M
α : Type u_13
β : Type u_14
x✝ y✝ : α ⊕ β →₀ M
⊢ __src✝.toFun (x✝ + y✝) = __src✝.toFun x✝ + __src✝.toFun y✝
state_after: no goals
tactic: ext <;>
        simp only [Equiv.toFun_as_coe, Prod.fst_add, Prod.snd_add, add_apply,
          snd_sumFinsuppEquivProdFinsupp, fst_sumFinsuppEquivProdFinsupp]
Theorem: ConjClasses.map_surjective
File: Mathlib/Algebra/Group/Conj.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝¹ : Monoid α
inst✝ : Monoid β
f : α →* β
hf : Function.Surjective ⇑f
⊢ Function.Surjective (map f)
state_after: α : Type u
β : Type v
inst✝¹ : Monoid α
inst✝ : Monoid β
f : α →* β
hf : Function.Surjective ⇑f
b : ConjClasses β
⊢ ∃ a, map f a = b
tactic: intro b
state_before: α : Type u
β : Type v
inst✝¹ : Monoid α
inst✝ : Monoid β
f : α →* β
hf : Function.Surjective ⇑f
b : ConjClasses β
⊢ ∃ a, map f a = b
state_after: case intro
α : Type u
β : Type v
inst✝¹ : Monoid α
inst✝ : Monoid β
f : α →* β
hf : Function.Surjective ⇑f
b : β
⊢ ∃ a, map f a = ConjClasses.mk b
tactic: obtain ⟨b, rfl⟩ := ConjClasses.mk_surjective b
state_before: case intro
α : Type u
β : Type v
inst✝¹ : Monoid α
inst✝ : Monoid β
f : α →* β
hf : Function.Surjective ⇑f
b : β
⊢ ∃ a, map f a = ConjClasses.mk b
state_after: case intro.intro
α : Type u
β : Type v
inst✝¹ : Monoid α
inst✝ : Monoid β
f : α →* β
hf : Function.Surjective ⇑f
a : α
⊢ ∃ a_1, map f a_1 = ConjClasses.mk (f a)
tactic: obtain ⟨a, rfl⟩ := hf b
state_before: case intro.intro
α : Type u
β : Type v
inst✝¹ : Monoid α
inst✝ : Monoid β
f : α →* β
hf : Function.Surjective ⇑f
a : α
⊢ ∃ a_1, map f a_1 = ConjClasses.mk (f a)
state_after: no goals
tactic: exact ⟨ConjClasses.mk a, rfl⟩
Theorem: MeasureTheory.SimpleFunc.posPart_sub_negPart
File: Mathlib/MeasureTheory/Integral/Bochner.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝² : LinearOrder E
inst✝¹ : Zero E
inst✝ : MeasurableSpace α
f : α →ₛ ℝ
⊢ f.posPart - f.negPart = f
state_after: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝² : LinearOrder E
inst✝¹ : Zero E
inst✝ : MeasurableSpace α
f : α →ₛ ℝ
⊢ map (fun b => max b 0) f - map (fun b => max b 0) (-f) = f
tactic: simp only [posPart, negPart]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝² : LinearOrder E
inst✝¹ : Zero E
inst✝ : MeasurableSpace α
f : α →ₛ ℝ
⊢ map (fun b => max b 0) f - map (fun b => max b 0) (-f) = f
state_after: case H
α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝² : LinearOrder E
inst✝¹ : Zero E
inst✝ : MeasurableSpace α
f : α →ₛ ℝ
a : α
⊢ ↑(map (fun b => max b 0) f - map (fun b => max b 0) (-f)) a = ↑f a
tactic: ext a
state_before: case H
α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝² : LinearOrder E
inst✝¹ : Zero E
inst✝ : MeasurableSpace α
f : α →ₛ ℝ
a : α
⊢ ↑(map (fun b => max b 0) f - map (fun b => max b 0) (-f)) a = ↑f a
state_after: case H
α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝² : LinearOrder E
inst✝¹ : Zero E
inst✝ : MeasurableSpace α
f : α →ₛ ℝ
a : α
⊢ (↑(map (fun b => max b 0) f) - ↑(map (fun b => max b 0) (-f))) a = ↑f a
tactic: rw [coe_sub]
state_before: case H
α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝² : LinearOrder E
inst✝¹ : Zero E
inst✝ : MeasurableSpace α
f : α →ₛ ℝ
a : α
⊢ (↑(map (fun b => max b 0) f) - ↑(map (fun b => max b 0) (-f))) a = ↑f a
state_after: no goals
tactic: exact max_zero_sub_eq_self (f a)
Theorem: CategoryTheory.Sieve.pullback_id
File: Mathlib/CategoryTheory/Sites/Sieves.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : Y ⟶ X
S R : Sieve X
⊢ pullback (𝟙 X) S = S
state_after: no goals
tactic: simp [Sieve.ext_iff]
Theorem: Nat.fst_mem_divisors_of_mem_antidiagonal
File: Mathlib/NumberTheory/Divisors.lean

Proof steps:
state_before: n : ℕ
x : ℕ × ℕ
h : x ∈ n.divisorsAntidiagonal
⊢ x.1 ∈ n.divisors
state_after: n : ℕ
x : ℕ × ℕ
h : x.1 * x.2 = n ∧ n ≠ 0
⊢ x.1 ∈ n.divisors
tactic: rw [mem_divisorsAntidiagonal] at h
state_before: n : ℕ
x : ℕ × ℕ
h : x.1 * x.2 = n ∧ n ≠ 0
⊢ x.1 ∈ n.divisors
state_after: no goals
tactic: simp [Dvd.intro _ h.1, h.2]
Theorem: CommMonoid.toMonoid_injective
File: Mathlib/Algebra/Group/Ext.lean

Proof steps:
state_before: M : Type u
⊢ Injective (@toMonoid M)
state_after: case mk.mk
M : Type u
toMonoid✝¹ : Monoid M
mul_comm✝¹ : ∀ (a b : M), a * b = b * a
toMonoid✝ : Monoid M
mul_comm✝ : ∀ (a b : M), a * b = b * a
h : toMonoid = toMonoid
⊢ mk mul_comm✝¹ = mk mul_comm✝
tactic: rintro ⟨⟩ ⟨⟩ h
state_before: case mk.mk
M : Type u
toMonoid✝¹ : Monoid M
mul_comm✝¹ : ∀ (a b : M), a * b = b * a
toMonoid✝ : Monoid M
mul_comm✝ : ∀ (a b : M), a * b = b * a
h : toMonoid = toMonoid
⊢ mk mul_comm✝¹ = mk mul_comm✝
state_after: no goals
tactic: congr
Theorem: isCycle_finRotate
File: Mathlib/GroupTheory/Perm/Fin.lean

Proof steps:
state_before: n : ℕ
⊢ (finRotate (n + 2)).IsCycle
state_after: n : ℕ
x : Fin (n + 2)
hx' : (finRotate (n + 2)) x ≠ x
⊢ (finRotate (n + 2) ^ ↑↑x) 0 = x
tactic: refine ⟨0, by simp, fun x hx' => ⟨x, ?_⟩⟩
state_before: n : ℕ
x : Fin (n + 2)
hx' : (finRotate (n + 2)) x ≠ x
⊢ (finRotate (n + 2) ^ ↑↑x) 0 = x
state_after: n : ℕ
x : Fin (n + 2)
⊢ (finRotate (n + 2) ^ ↑↑x) 0 = x
tactic: clear hx'
state_before: n : ℕ
x : Fin (n + 2)
⊢ (finRotate (n + 2) ^ ↑↑x) 0 = x
state_after: case mk
n x : ℕ
hx : x < n + 2
⊢ (finRotate (n + 2) ^ ↑↑⟨x, hx⟩) 0 = ⟨x, hx⟩
tactic: cases' x with x hx
state_before: case mk
n x : ℕ
hx : x < n + 2
⊢ (finRotate (n + 2) ^ ↑↑⟨x, hx⟩) 0 = ⟨x, hx⟩
state_after: case mk
n x : ℕ
hx : x < n + 2
⊢ ↑((finRotate (n + 2) ^ ↑⟨x, hx⟩) 0) = ↑⟨x, hx⟩
tactic: rw [zpow_natCast, Fin.ext_iff, Fin.val_mk]
state_before: case mk
n x : ℕ
hx : x < n + 2
⊢ ↑((finRotate (n + 2) ^ ↑⟨x, hx⟩) 0) = ↑⟨x, hx⟩
state_after: case mk.zero
n : ℕ
hx : 0 < n + 2
⊢ ↑((finRotate (n + 2) ^ ↑⟨0, hx⟩) 0) = ↑⟨0, hx⟩

case mk.succ
n x : ℕ
ih : ∀ (hx : x < n + 2), ↑((finRotate (n + 2) ^ ↑⟨x, hx⟩) 0) = ↑⟨x, hx⟩
hx : x + 1 < n + 2
⊢ ↑((finRotate (n + 2) ^ ↑⟨x + 1, hx⟩) 0) = ↑⟨x + 1, hx⟩
tactic: induction' x with x ih
state_before: case mk.succ
n x : ℕ
ih : ∀ (hx : x < n + 2), ↑((finRotate (n + 2) ^ ↑⟨x, hx⟩) 0) = ↑⟨x, hx⟩
hx : x + 1 < n + 2
⊢ ↑((finRotate (n + 2) ^ ↑⟨x + 1, hx⟩) 0) = ↑⟨x + 1, hx⟩
state_after: case mk.succ
n x : ℕ
ih : ∀ (hx : x < n + 2), ↑((finRotate (n + 2) ^ ↑⟨x, hx⟩) 0) = ↑⟨x, hx⟩
hx : x + 1 < n + 2
⊢ (finRotate (n + 2) ^ x) 0 ≠ Fin.last (n + 1)
tactic: rw [pow_succ', Perm.mul_apply, coe_finRotate_of_ne_last, ih (lt_trans x.lt_succ_self hx)]
state_before: case mk.succ
n x : ℕ
ih : ∀ (hx : x < n + 2), ↑((finRotate (n + 2) ^ ↑⟨x, hx⟩) 0) = ↑⟨x, hx⟩
hx : x + 1 < n + 2
⊢ (finRotate (n + 2) ^ x) 0 ≠ Fin.last (n + 1)
state_after: case mk.succ
n x : ℕ
ih : ∀ (hx : x < n + 2), ↑((finRotate (n + 2) ^ ↑⟨x, hx⟩) 0) = ↑⟨x, hx⟩
hx : x + 1 < n + 2
⊢ ¬↑⟨x, ⋯⟩ = n + 1
tactic: rw [Ne, Fin.ext_iff, ih (lt_trans x.lt_succ_self hx), Fin.val_last]
state_before: case mk.succ
n x : ℕ
ih : ∀ (hx : x < n + 2), ↑((finRotate (n + 2) ^ ↑⟨x, hx⟩) 0) = ↑⟨x, hx⟩
hx : x + 1 < n + 2
⊢ ¬↑⟨x, ⋯⟩ = n + 1
state_after: no goals
tactic: exact ne_of_lt (Nat.lt_of_succ_lt_succ hx)
Theorem: PartialOrder.ext
File: Mathlib/Order/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
A B : PartialOrder α
H : ∀ (x y : α), x ≤ y ↔ x ≤ y
⊢ A = B
state_after: case a.a.le.h.h.a
ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
A B : PartialOrder α
H : ∀ (x y : α), x ≤ y ↔ x ≤ y
x y : α
⊢ x ≤ y ↔ x ≤ y
tactic: ext x y
state_before: case a.a.le.h.h.a
ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
A B : PartialOrder α
H : ∀ (x y : α), x ≤ y ↔ x ≤ y
x y : α
⊢ x ≤ y ↔ x ≤ y
state_after: no goals
tactic: exact H x y
Theorem: FreeAbelianGroup.toFinsupp_comp_toFreeAbelianGroup
File: Mathlib/GroupTheory/FreeAbelianGroupFinsupp.lean

Proof steps:
state_before: X : Type u_1
⊢ toFinsupp.comp toFreeAbelianGroup = AddMonoidHom.id (X →₀ ℤ)
state_after: case H.h1.h
X : Type u_1
x y : X
⊢ (((toFinsupp.comp toFreeAbelianGroup).comp (singleAddHom x)) 1) y =
    (((AddMonoidHom.id (X →₀ ℤ)).comp (singleAddHom x)) 1) y
tactic: ext x y
state_before: case H.h1.h
X : Type u_1
x y : X
⊢ (((toFinsupp.comp toFreeAbelianGroup).comp (singleAddHom x)) 1) y =
    (((AddMonoidHom.id (X →₀ ℤ)).comp (singleAddHom x)) 1) y
state_after: case H.h1.h
X : Type u_1
x y : X
⊢ (((toFinsupp.comp toFreeAbelianGroup).comp (singleAddHom x)) 1) y = ((singleAddHom x) 1) y
tactic: simp only [AddMonoidHom.id_comp]
state_before: case H.h1.h
X : Type u_1
x y : X
⊢ (((toFinsupp.comp toFreeAbelianGroup).comp (singleAddHom x)) 1) y = ((singleAddHom x) 1) y
state_after: case H.h1.h
X : Type u_1
x y : X
⊢ ((toFinsupp.comp ((smulAddHom ℤ (FreeAbelianGroup X)).flip (of x))) 1) y = ((singleAddHom x) 1) y
tactic: rw [AddMonoidHom.comp_assoc, Finsupp.toFreeAbelianGroup_comp_singleAddHom]
state_before: case H.h1.h
X : Type u_1
x y : X
⊢ ((toFinsupp.comp ((smulAddHom ℤ (FreeAbelianGroup X)).flip (of x))) 1) y = ((singleAddHom x) 1) y
state_after: no goals
tactic: simp only [toFinsupp, AddMonoidHom.coe_comp, Finsupp.singleAddHom_apply, Function.comp_apply,
    one_smul, lift.of, AddMonoidHom.flip_apply, smulAddHom_apply, AddMonoidHom.id_apply]
Theorem: AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.inv_invApp
File: Mathlib/Geometry/RingedSpace/OpenImmersion.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : LocallyRingedSpace
f : X ⟶ Y
H : IsOpenImmersion f
U : Opens ↑X.toTopCat
⊢ (Opens.map f.val.base).op.obj (op ((opensFunctor f).obj U)) = op U
state_after: no goals
tactic: simp [Opens.map, Set.preimage_image_eq _ H.base_open.inj]
Theorem: ConvexCone.Blunt.salient
File: Mathlib/Analysis/Convex/Cone/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommGroup E
inst✝ : SMul 𝕜 E
S✝ S : ConvexCone 𝕜 E
⊢ S.Blunt → S.Salient
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommGroup E
inst✝ : SMul 𝕜 E
S✝ S : ConvexCone 𝕜 E
⊢ ¬S.Pointed → ¬S.Flat
tactic: rw [salient_iff_not_flat, blunt_iff_not_pointed]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommGroup E
inst✝ : SMul 𝕜 E
S✝ S : ConvexCone 𝕜 E
⊢ ¬S.Pointed → ¬S.Flat
state_after: no goals
tactic: exact mt Flat.pointed
Theorem: CategoryTheory.Presieve.extension_iff_amalgamation
File: Mathlib/CategoryTheory/Sites/IsSheafFor.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P✝ Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
P : Cᵒᵖ ⥤ Type v₁
x : S.functor ⟶ P
g : yoneda.obj X ⟶ P
⊢ S.functorInclusion ≫ g = x ↔ (↑(natTransEquivCompatibleFamily x)).IsAmalgamation (yonedaEquiv g)
state_after: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P✝ Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
P : Cᵒᵖ ⥤ Type v₁
x : S.functor ⟶ P
g : yoneda.obj X ⟶ P
⊢ S.functorInclusion ≫ g = x ↔ ∀ ⦃Y : C⦄ (f : Y ⟶ X) (h : S.arrows f), P.map f.op (yonedaEquiv g) = x.app (op Y) ⟨f, h⟩
tactic: change _ ↔ ∀ ⦃Y : C⦄ (f : Y ⟶ X) (h : S f), P.map f.op (yonedaEquiv g) = x.app (op Y) ⟨f, h⟩
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P✝ Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
P : Cᵒᵖ ⥤ Type v₁
x : S.functor ⟶ P
g : yoneda.obj X ⟶ P
⊢ S.functorInclusion ≫ g = x ↔ ∀ ⦃Y : C⦄ (f : Y ⟶ X) (h : S.arrows f), P.map f.op (yonedaEquiv g) = x.app (op Y) ⟨f, h⟩
state_after: case mp
C : Type u₁
inst✝ : Category.{v₁, u₁} C
P✝ Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
P : Cᵒᵖ ⥤ Type v₁
x : S.functor ⟶ P
g : yoneda.obj X ⟶ P
⊢ S.functorInclusion ≫ g = x → ∀ ⦃Y : C⦄ (f : Y ⟶ X) (h : S.arrows f), P.map f.op (yonedaEquiv g) = x.app (op Y) ⟨f, h⟩

case mpr
C : Type u₁
inst✝ : Category.{v₁, u₁} C
P✝ Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
P : Cᵒᵖ ⥤ Type v₁
x : S.functor ⟶ P
g : yoneda.obj X ⟶ P
⊢ (∀ ⦃Y : C⦄ (f : Y ⟶ X) (h : S.arrows f), P.map f.op (yonedaEquiv g) = x.app (op Y) ⟨f, h⟩) →
    S.functorInclusion ≫ g = x
tactic: constructor
Theorem: Fintype.card_eq_zero_iff
File: Mathlib/Data/Fintype/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : Fintype α
inst✝ : Fintype β
⊢ card α = 0 ↔ IsEmpty α
state_after: no goals
tactic: rw [card, Finset.card_eq_zero, univ_eq_empty_iff]