ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: ContinuousMultilinearMap.curryFinFinset_apply_const
File: Mathlib/Analysis/NormedSpace/Multilinear/Curry.lean

Proof steps:
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin n.succ → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁴ : Fintype ι
inst✝¹³ : Fintype ι'
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁷ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁶ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁵ : (i : Fin n.succ) → NormedAddCommGroup (Ei i)
inst✝⁴ : (i : Fin n.succ) → NormedSpace 𝕜 (Ei i)
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
k l : ℕ
s : Finset (Fin n)
hk : s.card = k
hl : sᶜ.card = l
f : ContinuousMultilinearMap 𝕜 (fun i => G) G'
x y : G
⊢ ((((curryFinFinset 𝕜 G G' hk hl) f) fun x_1 => x) fun x => y) = f (s.piecewise (fun x_1 => x) fun x => y)
state_after: 𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin n.succ → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁴ : Fintype ι
inst✝¹³ : Fintype ι'
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁷ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁶ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁵ : (i : Fin n.succ) → NormedAddCommGroup (Ei i)
inst✝⁴ : (i : Fin n.succ) → NormedSpace 𝕜 (Ei i)
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
k l : ℕ
s : Finset (Fin n)
hk : s.card = k
hl : sᶜ.card = l
f : ContinuousMultilinearMap 𝕜 (fun i => G) G'
x y : G
⊢ ((curryFinFinset 𝕜 G G' hk hl).symm ((curryFinFinset 𝕜 G G' hk hl) f)) (s.piecewise (fun x_1 => x) fun x => y) =
    f (s.piecewise (fun x_1 => x) fun x => y)
tactic: refine (curryFinFinset_symm_apply_piecewise_const hk hl _ _ _).symm.trans ?_
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin n.succ → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁴ : Fintype ι
inst✝¹³ : Fintype ι'
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁷ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁶ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁵ : (i : Fin n.succ) → NormedAddCommGroup (Ei i)
inst✝⁴ : (i : Fin n.succ) → NormedSpace 𝕜 (Ei i)
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
k l : ℕ
s : Finset (Fin n)
hk : s.card = k
hl : sᶜ.card = l
f : ContinuousMultilinearMap 𝕜 (fun i => G) G'
x y : G
⊢ ((curryFinFinset 𝕜 G G' hk hl).symm ((curryFinFinset 𝕜 G G' hk hl) f)) (s.piecewise (fun x_1 => x) fun x => y) =
    f (s.piecewise (fun x_1 => x) fun x => y)
state_after: no goals
tactic: rw [LinearIsometryEquiv.symm_apply_apply]
Theorem: Submonoid.mrange_inl
File: Mathlib/Algebra/Group/Submonoid/Operations.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
⊢ mrange (inl M N) = ⊤.prod ⊥
state_after: no goals
tactic: simpa only [mrange_eq_map] using map_inl ⊤
Theorem: IsPrimitiveRoot.zmodEquivZPowers_symm_apply_zpow
File: Mathlib/RingTheory/RootsOfUnity/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
G : Type u_3
R : Type u_4
S : Type u_5
F : Type u_6
inst✝³ : CommMonoid M
inst✝² : CommMonoid N
inst✝¹ : DivisionCommMonoid G
k l : ℕ
inst✝ : CommRing R
ζ : Rˣ
h : IsPrimitiveRoot ζ k
i : ℤ
⊢ h.zmodEquivZPowers.symm (Additive.ofMul ⟨ζ ^ i, ⋯⟩) = ↑i
state_after: no goals
tactic: rw [← h.zmodEquivZPowers.symm_apply_apply i, zmodEquivZPowers_apply_coe_int]
Theorem: List.pairwise_of_reflexive_of_forall_ne
File: Mathlib/Data/List/Pairwise.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
R S T : α → α → Prop
a : α
l✝ l : List α
r : α → α → Prop
hr : Reflexive r
h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → a ≠ b → r a b
⊢ Pairwise r l
state_after: α : Type u_1
β : Type u_2
R S T : α → α → Prop
a : α
l✝ l : List α
r : α → α → Prop
hr : Reflexive r
h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → a ≠ b → r a b
⊢ ∀ {a b : α}, [a, b] <+ l → r a b
tactic: rw [pairwise_iff_forall_sublist]
state_before: α : Type u_1
β : Type u_2
R S T : α → α → Prop
a : α
l✝ l : List α
r : α → α → Prop
hr : Reflexive r
h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → a ≠ b → r a b
⊢ ∀ {a b : α}, [a, b] <+ l → r a b
state_after: α : Type u_1
β : Type u_2
R S T : α → α → Prop
a✝ : α
l✝ l : List α
r : α → α → Prop
hr : Reflexive r
h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → a ≠ b → r a b
a b : α
hab : [a, b] <+ l
⊢ r a b
tactic: intro a b hab
state_before: α : Type u_1
β : Type u_2
R S T : α → α → Prop
a✝ : α
l✝ l : List α
r : α → α → Prop
hr : Reflexive r
h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → a ≠ b → r a b
a b : α
hab : [a, b] <+ l
⊢ r a b
state_after: no goals
tactic: if heq : a = b then
    cases heq; apply hr
  else
    apply h <;> try (apply hab.subset; simp)
    exact heq
Theorem: Multiset.esymm_neg
File: Mathlib/RingTheory/Polynomial/Vieta.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommRing R
s : Multiset R
k : ℕ
⊢ (map Neg.neg s).esymm k = (-1) ^ k * s.esymm k
state_after: R : Type u_1
inst✝ : CommRing R
s : Multiset R
k : ℕ
⊢ ∀ x ∈ powersetCard k s, (prod ∘ map Neg.neg) x = (-1) ^ k * x.prod
tactic: rw [esymm, esymm, ← Multiset.sum_map_mul_left, Multiset.powersetCard_map, Multiset.map_map,
    map_congr rfl]
state_before: R : Type u_1
inst✝ : CommRing R
s : Multiset R
k : ℕ
⊢ ∀ x ∈ powersetCard k s, (prod ∘ map Neg.neg) x = (-1) ^ k * x.prod
state_after: R : Type u_1
inst✝ : CommRing R
s : Multiset R
k : ℕ
x : Multiset R
hx : x ∈ powersetCard k s
⊢ (prod ∘ map Neg.neg) x = (-1) ^ k * x.prod
tactic: intro x hx
state_before: R : Type u_1
inst✝ : CommRing R
s : Multiset R
k : ℕ
x : Multiset R
hx : x ∈ powersetCard k s
⊢ (prod ∘ map Neg.neg) x = (-1) ^ k * x.prod
state_after: R : Type u_1
inst✝ : CommRing R
s : Multiset R
k : ℕ
x : Multiset R
hx : x ∈ powersetCard k s
⊢ (prod ∘ map Neg.neg) x = (map (Function.const R (-1)) x).prod * x.prod
tactic: rw [(mem_powersetCard.mp hx).right.symm, ← prod_replicate, ← Multiset.map_const]
state_before: R : Type u_1
inst✝ : CommRing R
s : Multiset R
k : ℕ
x : Multiset R
hx : x ∈ powersetCard k s
⊢ (prod ∘ map Neg.neg) x = (map (Function.const R (-1)) x).prod * x.prod
state_after: R : Type u_1
inst✝ : CommRing R
s : Multiset R
k : ℕ
x : Multiset R
hx : x ∈ powersetCard k s
⊢ (prod ∘ map Neg.neg) x = (map (Function.const R (-1)) x).prod * (map (fun x => x) x).prod
tactic: nth_rw 3 [← map_id' x]
state_before: R : Type u_1
inst✝ : CommRing R
s : Multiset R
k : ℕ
x : Multiset R
hx : x ∈ powersetCard k s
⊢ (prod ∘ map Neg.neg) x = (map (Function.const R (-1)) x).prod * (map (fun x => x) x).prod
state_after: R : Type u_1
inst✝ : CommRing R
s : Multiset R
k : ℕ
x : Multiset R
hx : x ∈ powersetCard k s
⊢ ∀ x_1 ∈ x, Function.const R (-1) x_1 * x_1 = -x_1
tactic: rw [← prod_map_mul, map_congr rfl, Function.comp_apply]
state_before: R : Type u_1
inst✝ : CommRing R
s : Multiset R
k : ℕ
x : Multiset R
hx : x ∈ powersetCard k s
⊢ ∀ x_1 ∈ x, Function.const R (-1) x_1 * x_1 = -x_1
state_after: no goals
tactic: exact fun z _ => neg_one_mul z
Theorem: Set.prod_eq_iff_eq
File: Mathlib/Data/Set/Prod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
ht : t.Nonempty
⊢ s ×ˢ t = s₁ ×ˢ t ↔ s = s₁
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
ht : t.Nonempty
⊢ s = ∅ ∧ s₁ = ∅ → s = s₁
tactic: simp_rw [prod_eq_prod_iff, ht.ne_empty, and_true_iff, or_iff_left_iff_imp,
    or_false_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
ht : t.Nonempty
⊢ s = ∅ ∧ s₁ = ∅ → s = s₁
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
ht : t.Nonempty
⊢ ∅ = ∅
tactic: rintro ⟨rfl, rfl⟩
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
ht : t.Nonempty
⊢ ∅ = ∅
state_after: no goals
tactic: rfl
Theorem: CompleteLattice.Iic_coatomic_of_compact_element
File: Mathlib/Order/CompactlyGenerated/Basic.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
inst✝ : CompleteLattice α
f : ι → α
k : α
h : IsCompactElement k
⊢ IsCoatomic ↑(Iic k)
state_after: case eq_top_or_exists_le_coatom
ι : Sort u_1
α : Type u_2
inst✝ : CompleteLattice α
f : ι → α
k : α
h : IsCompactElement k
⊢ ∀ (b : ↑(Iic k)), b = ⊤ ∨ ∃ a, IsCoatom a ∧ b ≤ a
tactic: constructor
state_before: case eq_top_or_exists_le_coatom
ι : Sort u_1
α : Type u_2
inst✝ : CompleteLattice α
f : ι → α
k : α
h : IsCompactElement k
⊢ ∀ (b : ↑(Iic k)), b = ⊤ ∨ ∃ a, IsCoatom a ∧ b ≤ a
state_after: case eq_top_or_exists_le_coatom.mk
ι : Sort u_1
α : Type u_2
inst✝ : CompleteLattice α
f : ι → α
k : α
h : IsCompactElement k
b : α
hbk : b ∈ Iic k
⊢ ⟨b, hbk⟩ = ⊤ ∨ ∃ a, IsCoatom a ∧ ⟨b, hbk⟩ ≤ a
tactic: rintro ⟨b, hbk⟩
state_before: case eq_top_or_exists_le_coatom.mk
ι : Sort u_1
α : Type u_2
inst✝ : CompleteLattice α
f : ι → α
k : α
h : IsCompactElement k
b : α
hbk : b ∈ Iic k
⊢ ⟨b, hbk⟩ = ⊤ ∨ ∃ a, IsCoatom a ∧ ⟨b, hbk⟩ ≤ a
state_after: case eq_top_or_exists_le_coatom.mk.inl
ι : Sort u_1
α : Type u_2
inst✝ : CompleteLattice α
f : ι → α
b : α
h : IsCompactElement b
hbk : b ∈ Iic b
⊢ ⟨b, hbk⟩ = ⊤ ∨ ∃ a, IsCoatom a ∧ ⟨b, hbk⟩ ≤ a

case eq_top_or_exists_le_coatom.mk.inr
ι : Sort u_1
α : Type u_2
inst✝ : CompleteLattice α
f : ι → α
k : α
h : IsCompactElement k
b : α
hbk : b ∈ Iic k
H : b ≠ k
⊢ ⟨b, hbk⟩ = ⊤ ∨ ∃ a, IsCoatom a ∧ ⟨b, hbk⟩ ≤ a
tactic: obtain rfl | H := eq_or_ne b k
state_before: case eq_top_or_exists_le_coatom.mk.inr
ι : Sort u_1
α : Type u_2
inst✝ : CompleteLattice α
f : ι → α
k : α
h : IsCompactElement k
b : α
hbk : b ∈ Iic k
H : b ≠ k
⊢ ⟨b, hbk⟩ = ⊤ ∨ ∃ a, IsCoatom a ∧ ⟨b, hbk⟩ ≤ a
state_after: case eq_top_or_exists_le_coatom.mk.inr.h
ι : Sort u_1
α : Type u_2
inst✝ : CompleteLattice α
f : ι → α
k : α
h : IsCompactElement k
b : α
hbk : b ∈ Iic k
H : b ≠ k
⊢ ∃ a, IsCoatom a ∧ ⟨b, hbk⟩ ≤ a
tactic: right
state_before: case eq_top_or_exists_le_coatom.mk.inr.h
ι : Sort u_1
α : Type u_2
inst✝ : CompleteLattice α
f : ι → α
k : α
h : IsCompactElement k
b : α
hbk : b ∈ Iic k
H : b ≠ k
⊢ ∃ a, IsCoatom a ∧ ⟨b, hbk⟩ ≤ a
state_after: case eq_top_or_exists_le_coatom.mk.inr.h.refine_2
ι : Sort u_1
α : Type u_2
inst✝ : CompleteLattice α
f : ι → α
k : α
h✝ : IsCompactElement k
b : α
hbk : b ∈ Iic k
H : b ≠ k
a : α
a₀ : a ∈ Iio k
ba : b ≤ a
h : ∀ z ∈ Iio k, a ≤ z → z = a
⊢ ∃ a, IsCoatom a ∧ ⟨b, hbk⟩ ≤ a

case eq_top_or_exists_le_coatom.mk.inr.h.refine_1
ι : Sort u_1
α : Type u_2
inst✝ : CompleteLattice α
f : ι → α
k : α
h : IsCompactElement k
b : α
hbk : b ∈ Iic k
H : b ≠ k
⊢ ∀ c ⊆ Iio k, IsChain (fun x x_1 => x ≤ x_1) c → ∀ y ∈ c, ∃ ub ∈ Iio k, ∀ z ∈ c, z ≤ ub
tactic: have ⟨a, a₀, ba, h⟩ := zorn_nonempty_partialOrder₀ (Set.Iio k) ?_ b (lt_of_le_of_ne hbk H)
Theorem: EllipticCurve.map_a₄
File: Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
E : EllipticCurve R
A : Type v
inst✝ : CommRing A
φ : R →+* A
⊢ ↑((Units.map ↑φ) E.Δ') = (E.map φ).Δ
state_after: R : Type u
inst✝¹ : CommRing R
E : EllipticCurve R
A : Type v
inst✝ : CommRing A
φ : R →+* A
⊢ ↑φ E.Δ = φ E.Δ
tactic: simp only [Units.coe_map, coe_Δ', E.map_Δ]
state_before: R : Type u
inst✝¹ : CommRing R
E : EllipticCurve R
A : Type v
inst✝ : CommRing A
φ : R →+* A
⊢ ↑φ E.Δ = φ E.Δ
state_after: no goals
tactic: rfl
Theorem: Matrix.transpose_smul
File: Mathlib/Data/Matrix/Basic.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R✝ : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
R : Type u_10
inst✝ : SMul R α
c : R
M : Matrix m n α
⊢ (c • M)ᵀ = c • Mᵀ
state_after: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R✝ : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
R : Type u_10
inst✝ : SMul R α
c : R
M : Matrix m n α
i✝ : n
j✝ : m
⊢ (c • M)ᵀ i✝ j✝ = (c • Mᵀ) i✝ j✝
tactic: ext
state_before: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R✝ : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
R : Type u_10
inst✝ : SMul R α
c : R
M : Matrix m n α
i✝ : n
j✝ : m
⊢ (c • M)ᵀ i✝ j✝ = (c • Mᵀ) i✝ j✝
state_after: no goals
tactic: rfl
Theorem: AlgebraicGeometry.LocallyRingedSpace.Γevaluation_eq_zero_iff_not_mem_basicOpen
File: Mathlib/Geometry/RingedSpace/LocallyRingedSpace/ResidueField.lean

Proof steps:
state_before: X : LocallyRingedSpace
U : Opens ↑X.toTopCat
x : ↑X.toTopCat
f : ↑(X.presheaf.obj (op ⊤))
⊢ x ∈ ⊤
state_after: no goals
tactic: trivial
Theorem: CliffordAlgebra.ofBaseChange_tmul_ι
File: Mathlib/LinearAlgebra/CliffordAlgebra/BaseChange.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
V : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : AddCommGroup V
inst✝⁴ : Algebra R A
inst✝³ : Module R V
inst✝² : Module A V
inst✝¹ : IsScalarTower R A V
inst✝ : Invertible 2
Q : QuadraticForm R V
z : A
v : V
⊢ (ofBaseChange A Q) (z ⊗ₜ[R] (ι Q) v) = (ι (QuadraticForm.baseChange A Q)) (z ⊗ₜ[R] v)
state_after: R : Type u_1
A : Type u_2
V : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : AddCommGroup V
inst✝⁴ : Algebra R A
inst✝³ : Module R V
inst✝² : Module A V
inst✝¹ : IsScalarTower R A V
inst✝ : Invertible 2
Q : QuadraticForm R V
z : A
v : V
⊢ (algebraMap A (CliffordAlgebra (QuadraticForm.baseChange A Q))) z * (ofBaseChangeAux A Q) ((ι Q) v) =
    (ι (QuadraticForm.baseChange A Q)) (z ⊗ₜ[R] v)
tactic: show algebraMap _ _ z * ofBaseChangeAux A Q (ι Q v) = ι (Q.baseChange A) (z ⊗ₜ[R] v)
state_before: R : Type u_1
A : Type u_2
V : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : AddCommGroup V
inst✝⁴ : Algebra R A
inst✝³ : Module R V
inst✝² : Module A V
inst✝¹ : IsScalarTower R A V
inst✝ : Invertible 2
Q : QuadraticForm R V
z : A
v : V
⊢ (algebraMap A (CliffordAlgebra (QuadraticForm.baseChange A Q))) z * (ofBaseChangeAux A Q) ((ι Q) v) =
    (ι (QuadraticForm.baseChange A Q)) (z ⊗ₜ[R] v)
state_after: no goals
tactic: rw [ofBaseChangeAux_ι, ← Algebra.smul_def, ← map_smul, TensorProduct.smul_tmul', smul_eq_mul,
    mul_one]
Theorem: Cardinal.cantorFunctionAux_zero
File: Mathlib/Data/Real/Cardinality.lean

Proof steps:
state_before: c : ℝ
f✝ g : ℕ → Bool
n : ℕ
f : ℕ → Bool
⊢ cantorFunctionAux c f 0 = bif f 0 then 1 else 0
state_after: no goals
tactic: cases h : f 0 <;> simp [h]
Theorem: Submodule.instSMulSubtypeMemTorsion'_smul_coe
File: Mathlib/Algebra/Module/Torsion.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝⁵ : CommSemiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
S : Type u_3
inst✝² : CommMonoid S
inst✝¹ : DistribMulAction S M
inst✝ : SMulCommClass S R M
s : S
x : ↥(torsion' R M S)
⊢ s • ↑x ∈ torsion' R M S
state_after: case mk.intro
R : Type u_1
M : Type u_2
inst✝⁵ : CommSemiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
S : Type u_3
inst✝² : CommMonoid S
inst✝¹ : DistribMulAction S M
inst✝ : SMulCommClass S R M
s : S
x : M
a : S
h : a • x = 0
⊢ s • ↑⟨x, ⋯⟩ ∈ torsion' R M S
tactic: obtain ⟨x, a, h⟩ := x
state_before: case mk.intro
R : Type u_1
M : Type u_2
inst✝⁵ : CommSemiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
S : Type u_3
inst✝² : CommMonoid S
inst✝¹ : DistribMulAction S M
inst✝ : SMulCommClass S R M
s : S
x : M
a : S
h : a • x = 0
⊢ s • ↑⟨x, ⋯⟩ ∈ torsion' R M S
state_after: case h
R : Type u_1
M : Type u_2
inst✝⁵ : CommSemiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
S : Type u_3
inst✝² : CommMonoid S
inst✝¹ : DistribMulAction S M
inst✝ : SMulCommClass S R M
s : S
x : M
a : S
h : a • x = 0
⊢ a • s • ↑⟨x, ⋯⟩ = 0
tactic: use a
state_before: case h
R : Type u_1
M : Type u_2
inst✝⁵ : CommSemiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
S : Type u_3
inst✝² : CommMonoid S
inst✝¹ : DistribMulAction S M
inst✝ : SMulCommClass S R M
s : S
x : M
a : S
h : a • x = 0
⊢ a • s • ↑⟨x, ⋯⟩ = 0
state_after: case h
R : Type u_1
M : Type u_2
inst✝⁵ : CommSemiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
S : Type u_3
inst✝² : CommMonoid S
inst✝¹ : DistribMulAction S M
inst✝ : SMulCommClass S R M
s : S
x : M
a : S
h : a • x = 0
⊢ a • s • x = 0
tactic: dsimp
state_before: case h
R : Type u_1
M : Type u_2
inst✝⁵ : CommSemiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
S : Type u_3
inst✝² : CommMonoid S
inst✝¹ : DistribMulAction S M
inst✝ : SMulCommClass S R M
s : S
x : M
a : S
h : a • x = 0
⊢ a • s • x = 0
state_after: no goals
tactic: rw [smul_comm, h, smul_zero]
Theorem: ENNReal.inv_rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

Proof steps:
state_before: x : ℝ≥0∞
y : ℝ
⊢ x⁻¹ ^ y = (x ^ y)⁻¹
state_after: case inl
x : ℝ≥0∞
⊢ x⁻¹ ^ 0 = (x ^ 0)⁻¹

case inr
x : ℝ≥0∞
y : ℝ
hy : y ≠ 0
⊢ x⁻¹ ^ y = (x ^ y)⁻¹
tactic: rcases eq_or_ne y 0 with (rfl | hy)
state_before: case inr
x : ℝ≥0∞
y : ℝ
hy : y ≠ 0
⊢ x⁻¹ ^ y = (x ^ y)⁻¹
state_after: case inr
x : ℝ≥0∞
y : ℝ
hy : y < 0 ∨ 0 < y
⊢ x⁻¹ ^ y = (x ^ y)⁻¹
tactic: replace hy := hy.lt_or_lt
state_before: case inr
x : ℝ≥0∞
y : ℝ
hy : y < 0 ∨ 0 < y
⊢ x⁻¹ ^ y = (x ^ y)⁻¹
state_after: case inr.inl
y : ℝ
hy : y < 0 ∨ 0 < y
⊢ 0⁻¹ ^ y = (0 ^ y)⁻¹

case inr.inr
x : ℝ≥0∞
y : ℝ
hy : y < 0 ∨ 0 < y
h0 : x ≠ 0
⊢ x⁻¹ ^ y = (x ^ y)⁻¹
tactic: rcases eq_or_ne x 0 with (rfl | h0)
state_before: case inr.inr
x : ℝ≥0∞
y : ℝ
hy : y < 0 ∨ 0 < y
h0 : x ≠ 0
⊢ x⁻¹ ^ y = (x ^ y)⁻¹
state_after: case inr.inr.inl
y : ℝ
hy : y < 0 ∨ 0 < y
h0 : ⊤ ≠ 0
⊢ ⊤⁻¹ ^ y = (⊤ ^ y)⁻¹

case inr.inr.inr
x : ℝ≥0∞
y : ℝ
hy : y < 0 ∨ 0 < y
h0 : x ≠ 0
h_top : x ≠ ⊤
⊢ x⁻¹ ^ y = (x ^ y)⁻¹
tactic: rcases eq_or_ne x ⊤ with (rfl | h_top)
state_before: case inr.inr.inr
x : ℝ≥0∞
y : ℝ
hy : y < 0 ∨ 0 < y
h0 : x ≠ 0
h_top : x ≠ ⊤
⊢ x⁻¹ ^ y = (x ^ y)⁻¹
state_after: case inr.inr.inr.h
x : ℝ≥0∞
y : ℝ
hy : y < 0 ∨ 0 < y
h0 : x ≠ 0
h_top : x ≠ ⊤
⊢ x⁻¹ ^ y * x ^ y = 1
tactic: apply ENNReal.eq_inv_of_mul_eq_one_left
state_before: case inr.inr.inr.h
x : ℝ≥0∞
y : ℝ
hy : y < 0 ∨ 0 < y
h0 : x ≠ 0
h_top : x ≠ ⊤
⊢ x⁻¹ ^ y * x ^ y = 1
state_after: no goals
tactic: rw [← mul_rpow_of_ne_zero (ENNReal.inv_ne_zero.2 h_top) h0, ENNReal.inv_mul_cancel h0 h_top,
    one_rpow]
Theorem: FiberPrebundle.mem_pretrivializationAt_source
File: Mathlib/Topology/FiberBundle/Basic.lean

Proof steps:
state_before: ι : Type u_1
B : Type u_2
F : Type u_3
X : Type u_4
inst✝³ : TopologicalSpace X
E : B → Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e : Pretrivialization F TotalSpace.proj
b : B
x : E b
⊢ { proj := b, snd := x } ∈ (a.pretrivializationAt b).source
state_after: ι : Type u_1
B : Type u_2
F : Type u_3
X : Type u_4
inst✝³ : TopologicalSpace X
E : B → Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e : Pretrivialization F TotalSpace.proj
b : B
x : E b
⊢ b ∈ (a.pretrivializationAt b).baseSet
tactic: simp only [(a.pretrivializationAt b).source_eq, mem_preimage, TotalSpace.proj]
state_before: ι : Type u_1
B : Type u_2
F : Type u_3
X : Type u_4
inst✝³ : TopologicalSpace X
E : B → Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e : Pretrivialization F TotalSpace.proj
b : B
x : E b
⊢ b ∈ (a.pretrivializationAt b).baseSet
state_after: no goals
tactic: exact a.mem_base_pretrivializationAt b
Theorem: TopologicalSpace.eq_induced_by_maps_to_sierpinski
File: Mathlib/Topology/ContinuousFunction/T0Sierpinski.lean

Proof steps:
state_before: X : Type u_1
t : TopologicalSpace X
⊢ t = ⨅ u, induced (fun x => x ∈ u) sierpinskiSpace
state_after: case a
X : Type u_1
t : TopologicalSpace X
⊢ t ≤ ⨅ u, induced (fun x => x ∈ u) sierpinskiSpace

case a
X : Type u_1
t : TopologicalSpace X
⊢ ⨅ u, induced (fun x => x ∈ u) sierpinskiSpace ≤ t
tactic: apply le_antisymm
Theorem: Real.logb_self_eq_one_iff
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

Proof steps:
state_before: b x y : ℝ
h : logb b b = 1
h' : log b = 0
⊢ False
state_after: no goals
tactic: simp [logb, h'] at h
Theorem: CategoryTheory.ShortComplex.LeftHomologyData.ofIsColimitCokernelCofork_f'
File: Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.LeftHomologyData
A : C
hg : S.g = 0
c : CokernelCofork S.f
hc : IsColimit c
⊢ (ofIsColimitCokernelCofork S hg c hc).f' = S.f
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.LeftHomologyData
A : C
hg : S.g = 0
c : CokernelCofork S.f
hc : IsColimit c
⊢ S.f = S.f ≫ 𝟙 S.X₂
tactic: rw [← cancel_mono (ofIsColimitCokernelCofork S hg c hc).i, f'_i,
    ofIsColimitCokernelCofork_i]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.LeftHomologyData
A : C
hg : S.g = 0
c : CokernelCofork S.f
hc : IsColimit c
⊢ S.f = S.f ≫ 𝟙 S.X₂
state_after: no goals
tactic: rw [comp_id]
Theorem: equivShrink_symm_mul
File: Mathlib/Logic/Small/Group.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Mul α
inst✝ : Small.{u_2, u_1} α
x y : Shrink.{u_2, u_1} α
⊢ (equivShrink α).symm (x * y) = (equivShrink α).symm x * (equivShrink α).symm y
state_after: α : Type u_1
inst✝¹ : Mul α
inst✝ : Small.{u_2, u_1} α
x y : Shrink.{u_2, u_1} α
⊢ (equivShrink α).symm ((equivShrink α).symm.symm ((equivShrink α).symm x * (equivShrink α).symm y)) =
    (equivShrink α).symm x * (equivShrink α).symm y
tactic: rw [Equiv.mul_def]
state_before: α : Type u_1
inst✝¹ : Mul α
inst✝ : Small.{u_2, u_1} α
x y : Shrink.{u_2, u_1} α
⊢ (equivShrink α).symm ((equivShrink α).symm.symm ((equivShrink α).symm x * (equivShrink α).symm y)) =
    (equivShrink α).symm x * (equivShrink α).symm y
state_after: no goals
tactic: simp
Theorem: mem_closure_zero_iff_norm
File: Mathlib/Analysis/Normed/Group/Basic.lean

Proof steps:
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝³ : SeminormedGroup E
inst✝² : SeminormedGroup F
inst✝¹ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
inst✝ : FunLike 𝓕 E F
x : E
⊢ x ∈ closure {1} ↔ ‖x‖ = 0
state_after: no goals
tactic: rw [← closedBall_zero', mem_closedBall_one_iff, (norm_nonneg' x).le_iff_eq]
Theorem: Subalgebra.mulMap'_surjective
File: Mathlib/LinearAlgebra/TensorProduct/Subalgebra.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
inst✝ : Algebra R S
A B : Subalgebra R S
⊢ Function.Surjective ⇑(A.mulMap' B)
state_after: no goals
tactic: simp_rw [mulMap', AlgEquiv.toAlgHom_eq_coe, AlgHom.coe_comp, AlgHom.coe_coe,
    EquivLike.comp_surjective, AlgHom.rangeRestrict_surjective]