1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: CategoryTheory.Subgroupoid.IsNormal.conj'
File: Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean

tactic: convert Sn.conj (Groupoid.inv p) hs
state_before: C : Type u
inst✝ : Groupoid C
S✝ S : Subgroupoid C
Sn : S.IsNormal
c✝ d✝ : C
p : d✝ ⟶ c✝
γ : c✝ ⟶ c✝
hs : γ ∈ S.arrows c✝ c✝
⊢ p ≫ γ ≫ Groupoid.inv p ∈ S.arrows d✝ d✝
state_after: case h.e'_4.h.e'_6
C : Type u
inst✝ : Groupoid C
S✝ S : Subgroupoid C
Sn : S.IsNormal
c✝ d✝ : C
p : d✝ ⟶ c✝
γ : c✝ ⟶ c✝
hs : γ ∈ S.arrows c✝ c✝
⊢ p = Groupoid.inv (Groupoid.inv p)

tactic: simp
state_before: case h.e'_4.h.e'_6
C : Type u
inst✝ : Groupoid C
S✝ S : Subgroupoid C
Sn : S.IsNormal
c✝ d✝ : C
p : d✝ ⟶ c✝
γ : c✝ ⟶ c✝
hs : γ ∈ S.arrows c✝ c✝
⊢ p = Groupoid.inv (Groupoid.inv p)
state_after: no goals
Theorem: UniformCauchySeqOnFilter.mono_left
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: intro u hu
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
p'' : Filter ι
hf : UniformCauchySeqOnFilter F p p'
hp : p'' ≤ p
⊢ UniformCauchySeqOnFilter F p'' p'
state_after: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
p'' : Filter ι
hf : UniformCauchySeqOnFilter F p p'
hp : p'' ≤ p
u : Set (β × β)
hu : u ∈ 𝓤 β
⊢ ∀ᶠ (m : (ι × ι) × α) in (p'' ×ˢ p'') ×ˢ p', (F m.1.1 m.2, F m.1.2 m.2) ∈ u

tactic: have := (hf u hu).filter_mono (p'.prod_mono_left (Filter.prod_mono hp hp))
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
p'' : Filter ι
hf : UniformCauchySeqOnFilter F p p'
hp : p'' ≤ p
u : Set (β × β)
hu : u ∈ 𝓤 β
⊢ ∀ᶠ (m : (ι × ι) × α) in (p'' ×ˢ p'') ×ˢ p', (F m.1.1 m.2, F m.1.2 m.2) ∈ u
state_after: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
p'' : Filter ι
hf : UniformCauchySeqOnFilter F p p'
hp : p'' ≤ p
u : Set (β × β)
hu : u ∈ 𝓤 β
this : ∀ᶠ (x : (ι × ι) × α) in (p'' ×ˢ p'') ×ˢ p', (F x.1.1 x.2, F x.1.2 x.2) ∈ u
⊢ ∀ᶠ (m : (ι × ι) × α) in (p'' ×ˢ p'') ×ˢ p', (F m.1.1 m.2, F m.1.2 m.2) ∈ u

tactic: exact this.mono (by simp)
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
p'' : Filter ι
hf : UniformCauchySeqOnFilter F p p'
hp : p'' ≤ p
u : Set (β × β)
hu : u ∈ 𝓤 β
this : ∀ᶠ (x : (ι × ι) × α) in (p'' ×ˢ p'') ×ˢ p', (F x.1.1 x.2, F x.1.2 x.2) ∈ u
⊢ ∀ᶠ (m : (ι × ι) × α) in (p'' ×ˢ p'') ×ˢ p', (F m.1.1 m.2, F m.1.2 m.2) ∈ u
state_after: no goals

tactic: simp
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
p'' : Filter ι
hf : UniformCauchySeqOnFilter F p p'
hp : p'' ≤ p
u : Set (β × β)
hu : u ∈ 𝓤 β
this : ∀ᶠ (x : (ι × ι) × α) in (p'' ×ˢ p'') ×ˢ p', (F x.1.1 x.2, F x.1.2 x.2) ∈ u
⊢ ∀ (x : (ι × ι) × α), (F x.1.1 x.2, F x.1.2 x.2) ∈ u → (F x.1.1 x.2, F x.1.2 x.2) ∈ u
state_after: no goals
Theorem: PrimeMultiset.coePNat_prime
File: Mathlib/Data/PNat/Factors.lean

tactic: rcases Multiset.mem_map.mp h with ⟨⟨_, hp'⟩, ⟨_, h_eq⟩⟩
state_before: v : PrimeMultiset
p : ℕ+
h : p ∈ v.toPNatMultiset
⊢ p.Prime
state_after: case intro.mk.intro
v : PrimeMultiset
p : ℕ+
h : p ∈ v.toPNatMultiset
val✝ : ℕ
hp' : Nat.Prime val✝
left✝ : ⟨val✝, hp'⟩ ∈ v
h_eq : Coe.coe ⟨val✝, hp'⟩ = p
⊢ p.Prime

tactic: exact h_eq ▸ hp'
state_before: case intro.mk.intro
v : PrimeMultiset
p : ℕ+
h : p ∈ v.toPNatMultiset
val✝ : ℕ
hp' : Nat.Prime val✝
left✝ : ⟨val✝, hp'⟩ ∈ v
h_eq : Coe.coe ⟨val✝, hp'⟩ = p
⊢ p.Prime
state_after: no goals
Theorem: Finset.mul_eq_one_iff
File: Mathlib/Data/Finset/Pointwise.lean

tactic: simp_rw [← coe_inj, coe_mul, coe_one, Set.mul_eq_one_iff, coe_singleton]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : DivisionMonoid α
s t : Finset α
⊢ s * t = 1 ↔ ∃ a b, s = {a} ∧ t = {b} ∧ a * b = 1
state_after: no goals
Theorem: MvPolynomial.vars_def
File: Mathlib/Algebra/MvPolynomial/Variables.lean

tactic: rw [vars]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p✝ q : MvPolynomial σ R
inst✝ : DecidableEq σ
p : MvPolynomial σ R
⊢ p.vars = p.degrees.toFinset
state_after: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p✝ q : MvPolynomial σ R
inst✝ : DecidableEq σ
p : MvPolynomial σ R
⊢ p.degrees.toFinset = p.degrees.toFinset

tactic: convert rfl
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p✝ q : MvPolynomial σ R
inst✝ : DecidableEq σ
p : MvPolynomial σ R
⊢ p.degrees.toFinset = p.degrees.toFinset
state_after: no goals
Theorem: sameRay_neg_smul_right_iff
File: Mathlib/LinearAlgebra/Ray.lean

tactic: rw [← sameRay_neg_iff, neg_neg, ← neg_smul, sameRay_smul_right_iff, neg_nonneg]
state_before: R : Type u_1
inst✝³ : LinearOrderedCommRing R
M : Type u_2
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : NoZeroSMulDivisors R M
v : M
r : R
⊢ SameRay R (-v) (r • v) ↔ r ≤ 0 ∨ v = 0
state_after: no goals
Theorem: LieSubmodule.lcs_le_self
File: Mathlib/Algebra/Lie/Nilpotent.lean

tactic: induction' k with k ih
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k : ℕ
N : LieSubmodule R L M
⊢ lcs k N ≤ N
state_after: case zero
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k : ℕ
N : LieSubmodule R L M
⊢ lcs 0 N ≤ N

case succ
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k✝ : ℕ
N : LieSubmodule R L M
k : ℕ
ih : lcs k N ≤ N
⊢ lcs (k + 1) N ≤ N

tactic: simp
state_before: case zero
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k : ℕ
N : LieSubmodule R L M
⊢ lcs 0 N ≤ N
state_after: no goals

tactic: simp only [lcs_succ]
state_before: case succ
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k✝ : ℕ
N : LieSubmodule R L M
k : ℕ
ih : lcs k N ≤ N
⊢ lcs (k + 1) N ≤ N
state_after: case succ
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k✝ : ℕ
N : LieSubmodule R L M
k : ℕ
ih : lcs k N ≤ N
⊢ ⁅⊤, lcs k N⁆ ≤ N

tactic: exact (LieSubmodule.mono_lie_right _ _ ⊤ ih).trans (N.lie_le_right ⊤)
state_before: case succ
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k✝ : ℕ
N : LieSubmodule R L M
k : ℕ
ih : lcs k N ≤ N
⊢ ⁅⊤, lcs k N⁆ ≤ N
state_after: no goals
Theorem: Ordnode.Valid'.eraseMin_aux
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: have := H.dual.eraseMax_aux
state_before: α : Type u_1
inst✝ : Preorder α
s : ℕ
l : Ordnode α
x : α
r : Ordnode α
o₁ : WithBot α
o₂ : WithTop α
H : Valid' o₁ (Ordnode.node s l x r) o₂
⊢ Valid' (↑(l.findMin' x)) (l.node' x r).eraseMin o₂ ∧ (l.node' x r).size = (l.node' x r).eraseMin.size + 1
state_after: α : Type u_1
inst✝ : Preorder α
s : ℕ
l : Ordnode α
x : α
r : Ordnode α
o₁ : WithBot α
o₂ : WithTop α
H : Valid' o₁ (Ordnode.node s l x r) o₂
this :
  Valid' o₂ (r.dual.node' x l.dual).eraseMax ↑(findMax' x l.dual) ∧
    (r.dual.node' x l.dual).size = (r.dual.node' x l.dual).eraseMax.size + 1
⊢ Valid' (↑(l.findMin' x)) (l.node' x r).eraseMin o₂ ∧ (l.node' x r).size = (l.node' x r).eraseMin.size + 1

tactic: rwa [← dual_node', size_dual, ← dual_eraseMin, size_dual, ← Valid'.dual_iff, findMax'_dual]
  at this
state_before: α : Type u_1
inst✝ : Preorder α
s : ℕ
l : Ordnode α
x : α
r : Ordnode α
o₁ : WithBot α
o₂ : WithTop α
H : Valid' o₁ (Ordnode.node s l x r) o₂
this :
  Valid' o₂ (r.dual.node' x l.dual).eraseMax ↑(findMax' x l.dual) ∧
    (r.dual.node' x l.dual).size = (r.dual.node' x l.dual).eraseMax.size + 1
⊢ Valid' (↑(l.findMin' x)) (l.node' x r).eraseMin o₂ ∧ (l.node' x r).size = (l.node' x r).eraseMin.size + 1
state_after: no goals
Theorem: PadicInt.unitCoeff_spec
File: Mathlib/NumberTheory/Padics/PadicIntegers.lean

tactic: apply Subtype.coe_injective
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
⊢ x = ↑(unitCoeff hx) * ↑p ^ x.valuation.natAbs
state_after: case a
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
⊢ (fun a => ↑a) x = (fun a => ↑a) (↑(unitCoeff hx) * ↑p ^ x.valuation.natAbs)

tactic: push_cast
state_before: case a
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
⊢ (fun a => ↑a) x = (fun a => ↑a) (↑(unitCoeff hx) * ↑p ^ x.valuation.natAbs)
state_after: case a
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
⊢ ↑x = ↑↑(unitCoeff hx) * ↑p ^ x.valuation.natAbs

tactic: convert repr using 2
state_before: case a
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
repr : ↑x = ↑↑(unitCoeff hx) * ↑p ^ x.valuation
⊢ ↑x = ↑↑(unitCoeff hx) * ↑p ^ x.valuation.natAbs
state_after: case h.e'_3.h.e'_6
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
repr : ↑x = ↑↑(unitCoeff hx) * ↑p ^ x.valuation
⊢ ↑p ^ x.valuation.natAbs = ↑p ^ x.valuation

tactic: rw [← zpow_natCast, Int.natAbs_of_nonneg (valuation_nonneg x)]
state_before: case h.e'_3.h.e'_6
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
repr : ↑x = ↑↑(unitCoeff hx) * ↑p ^ x.valuation
⊢ ↑p ^ x.valuation.natAbs = ↑p ^ x.valuation
state_after: no goals

tactic: rw [unitCoeff_coe, mul_assoc, ← zpow_add₀]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
⊢ ↑x = ↑↑(unitCoeff hx) * ↑p ^ x.valuation
state_after: p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
⊢ ↑x = ↑x * ↑p ^ (-x.valuation + x.valuation)

case ha
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
⊢ ↑p ≠ 0

tactic: simp
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
⊢ ↑x = ↑x * ↑p ^ (-x.valuation + x.valuation)
state_after: no goals

tactic: exact mod_cast hp.1.ne_zero
state_before: case ha
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
⊢ ↑p ≠ 0
state_after: no goals
Theorem: Polynomial.eq_of_monic_of_dvd_of_natDegree_le
File: Mathlib/Algebra/Polynomial/RingDivision.lean

tactic: convert eq_leadingCoeff_mul_of_monic_of_dvd_of_natDegree_le hp hdiv hdeg
state_before: R✝ : Type u
S : Type v
T : Type w
a b : R✝
n : ℕ
inst✝² : CommRing R✝
inst✝¹ : IsDomain R✝
p✝ q✝ : R✝[X]
R : Type u_1
inst✝ : CommRing R
p q : R[X]
hp : p.Monic
hq : q.Monic
hdiv : p ∣ q
hdeg : q.natDegree ≤ p.natDegree
⊢ q = p
state_after: case h.e'_3
R✝ : Type u
S : Type v
T : Type w
a b : R✝
n : ℕ
inst✝² : CommRing R✝
inst✝¹ : IsDomain R✝
p✝ q✝ : R✝[X]
R : Type u_1
inst✝ : CommRing R
p q : R[X]
hp : p.Monic
hq : q.Monic
hdiv : p ∣ q
hdeg : q.natDegree ≤ p.natDegree
⊢ p = C q.leadingCoeff * p

tactic: rw [hq.leadingCoeff, C_1, one_mul]
state_before: case h.e'_3
R✝ : Type u
S : Type v
T : Type w
a b : R✝
n : ℕ
inst✝² : CommRing R✝
inst✝¹ : IsDomain R✝
p✝ q✝ : R✝[X]
R : Type u_1
inst✝ : CommRing R
p q : R[X]
hp : p.Monic
hq : q.Monic
hdiv : p ∣ q
hdeg : q.natDegree ≤ p.natDegree
⊢ p = C q.leadingCoeff * p
state_after: no goals
Theorem: hasProd_one_iff_of_one_le
File: Mathlib/Topology/Algebra/InfiniteSum/Order.lean

tactic: refine ⟨fun hf' ↦ ?_, ?_⟩
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
inst✝² : OrderedCommMonoid α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
f g : ι → α
a a₁ a₂ : α
hf : ∀ (i : ι), 1 ≤ f i
⊢ HasProd f 1 ↔ f = 1
state_after: case refine_1
ι : Type u_1
κ : Type u_2
α : Type u_3
inst✝² : OrderedCommMonoid α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
f g : ι → α
a a₁ a₂ : α
hf : ∀ (i : ι), 1 ≤ f i
hf' : HasProd f 1
⊢ f = 1

case refine_2
ι : Type u_1
κ : Type u_2
α : Type u_3
inst✝² : OrderedCommMonoid α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
f g : ι → α
a a₁ a₂ : α
hf : ∀ (i : ι), 1 ≤ f i
⊢ f = 1 → HasProd f 1

tactic: ext i
state_before: case refine_1
ι : Type u_1
κ : Type u_2
α : Type u_3
inst✝² : OrderedCommMonoid α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
f g : ι → α
a a₁ a₂ : α
hf : ∀ (i : ι), 1 ≤ f i
hf' : HasProd f 1
⊢ f = 1
state_after: case refine_1.h
ι : Type u_1
κ : Type u_2
α : Type u_3
inst✝² : OrderedCommMonoid α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
f g : ι → α
a a₁ a₂ : α
hf : ∀ (i : ι), 1 ≤ f i
hf' : HasProd f 1
i : ι
⊢ f i = 1 i

tactic: exact (hf i).antisymm' (le_hasProd hf' _ fun j _ ↦ hf j)
state_before: case refine_1.h
ι : Type u_1
κ : Type u_2
α : Type u_3
inst✝² : OrderedCommMonoid α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
f g : ι → α
a a₁ a₂ : α
hf : ∀ (i : ι), 1 ≤ f i
hf' : HasProd f 1
i : ι
⊢ f i = 1 i
state_after: no goals

tactic: rintro rfl
state_before: case refine_2
ι : Type u_1
κ : Type u_2
α : Type u_3
inst✝² : OrderedCommMonoid α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
f g : ι → α
a a₁ a₂ : α
hf : ∀ (i : ι), 1 ≤ f i
⊢ f = 1 → HasProd f 1
state_after: case refine_2
ι : Type u_1
κ : Type u_2
α : Type u_3
inst✝² : OrderedCommMonoid α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
g : ι → α
a a₁ a₂ : α
hf : ∀ (i : ι), 1 ≤ 1 i
⊢ HasProd 1 1

tactic: exact hasProd_one
state_before: case refine_2
ι : Type u_1
κ : Type u_2
α : Type u_3
inst✝² : OrderedCommMonoid α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
g : ι → α
a a₁ a₂ : α
hf : ∀ (i : ι), 1 ≤ 1 i
⊢ HasProd 1 1
state_after: no goals
Theorem: Num.pred_succ
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [PosNum.pred'_succ']
state_before: α : Type u_1
p : PosNum
⊢ (pos p).succ'.pred'.toZNumNeg = ZNum.neg p
state_after: α : Type u_1
p : PosNum
⊢ (pos p).toZNumNeg = ZNum.neg p

tactic: rfl
state_before: α : Type u_1
p : PosNum
⊢ (pos p).toZNumNeg = ZNum.neg p
state_after: no goals

tactic: rw [ZNum.pred, ← toZNum_succ, Num.succ, PosNum.succ'_pred', toZNum]
state_before: α : Type u_1
p : PosNum
⊢ (ZNum.pos p).pred.succ = ZNum.pos p
state_after: no goals
Theorem: ZMod.ringChar_zmod_n
File: Mathlib/Data/ZMod/Basic.lean

tactic: rw [ringChar.eq_iff]
state_before: n : ℕ
⊢ ringChar (ZMod n) = n
state_after: n : ℕ
⊢ CharP (ZMod n) n

tactic: exact ZMod.charP n
state_before: n : ℕ
⊢ CharP (ZMod n) n
state_after: no goals
Theorem: ENNReal.toNNReal_sSup
File: Mathlib/Data/ENNReal/Real.lean

tactic: have hf : ∀ i, ((↑) : s → ℝ≥0∞) i ≠ ∞ := fun ⟨r, rs⟩ => hs r rs
state_before: ι : Sort u_1
f g : ι → ℝ≥0∞
a b c d : ℝ≥0∞
r p q : ℝ≥0
s : Set ℝ≥0∞
hs : ∀ r ∈ s, r ≠ ⊤
⊢ (sSup s).toNNReal = sSup (ENNReal.toNNReal '' s)
state_after: ι : Sort u_1
f g : ι → ℝ≥0∞
a b c d : ℝ≥0∞
r p q : ℝ≥0
s : Set ℝ≥0∞
hs : ∀ r ∈ s, r ≠ ⊤
hf : ∀ (i : { x // x ∈ s }), ↑i ≠ ⊤
⊢ (sSup s).toNNReal = sSup (ENNReal.toNNReal '' s)

tactic: simpa only [← sSup_range, ← image_eq_range, Subtype.range_coe_subtype] using (toNNReal_iSup hf)
state_before: ι : Sort u_1
f g : ι → ℝ≥0∞
a b c d : ℝ≥0∞
r p q : ℝ≥0
s : Set ℝ≥0∞
hs : ∀ r ∈ s, r ≠ ⊤
hf : ∀ (i : { x // x ∈ s }), ↑i ≠ ⊤
⊢ (sSup s).toNNReal = sSup (ENNReal.toNNReal '' s)
state_after: no goals
Theorem: Irrational.of_rat_sub
File: Mathlib/Data/Real/Irrational.lean

tactic: simpa only [sub_eq_add_neg] using h
state_before: q : ℚ
x y : ℝ
h : Irrational (↑q - x)
⊢ Irrational (↑q + -x)
state_after: no goals
Theorem: List.join_append
File: Mathlib/Data/List/Join.lean

tactic: induction L₁
state_before: α : Type u_1
β : Type u_2
L₁ L₂ : List (List α)
⊢ (L₁ ++ L₂).join = L₁.join ++ L₂.join
state_after: case nil
α : Type u_1
β : Type u_2
L₂ : List (List α)
⊢ ([] ++ L₂).join = [].join ++ L₂.join

case cons
α : Type u_1
β : Type u_2
L₂ : List (List α)
head✝ : List α
tail✝ : List (List α)
tail_ih✝ : (tail✝ ++ L₂).join = tail✝.join ++ L₂.join
⊢ (head✝ :: tail✝ ++ L₂).join = (head✝ :: tail✝).join ++ L₂.join

tactic: rfl
state_before: case nil
α : Type u_1
β : Type u_2
L₂ : List (List α)
⊢ ([] ++ L₂).join = [].join ++ L₂.join
state_after: no goals

tactic: simp [*]
state_before: case cons
α : Type u_1
β : Type u_2
L₂ : List (List α)
head✝ : List α
tail✝ : List (List α)
tail_ih✝ : (tail✝ ++ L₂).join = tail✝.join ++ L₂.join
⊢ (head✝ :: tail✝ ++ L₂).join = (head✝ :: tail✝).join ++ L₂.join
state_after: no goals
Theorem: finprod_one
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: have : (mulSupport fun x : PLift α => (fun _ => 1 : α → M) x.down) ⊆ (∅ : Finset (PLift α)) :=
  fun x h => by simp at h
state_before: G : Type u_1
M : Type u_2
N : Type u_3
α : Sort u_4
β : Sort u_5
ι : Sort u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
⊢ ∏ᶠ (x : α), 1 = 1
state_after: G : Type u_1
M : Type u_2
N : Type u_3
α : Sort u_4
β : Sort u_5
ι : Sort u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
this : (mulSupport fun x => (fun x => 1) x.down) ⊆ ↑∅
⊢ ∏ᶠ (x : α), 1 = 1

tactic: rw [finprod_eq_prod_plift_of_mulSupport_subset this, Finset.prod_empty]
state_before: G : Type u_1
M : Type u_2
N : Type u_3
α : Sort u_4
β : Sort u_5
ι : Sort u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
this : (mulSupport fun x => (fun x => 1) x.down) ⊆ ↑∅
⊢ ∏ᶠ (x : α), 1 = 1
state_after: no goals

tactic: simp at h
state_before: G : Type u_1
M : Type u_2
N : Type u_3
α : Sort u_4
β : Sort u_5
ι : Sort u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
x : PLift α
h : x ∈ mulSupport fun x => (fun x => 1) x.down
⊢ x ∈ ↑∅
state_after: no goals
Theorem: Matrix.mem_range_scalar_of_commute_transvectionStruct
File: Mathlib/LinearAlgebra/Matrix/Transvection.lean

tactic: refine mem_range_scalar_of_commute_stdBasisMatrix ?_
state_before: n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝⁴ : Field 𝕜
inst✝³ : DecidableEq n
inst✝² : DecidableEq p
inst✝¹ : CommRing R
i j : n
inst✝ : Fintype n
M : Matrix n n R
hM : ∀ (t : TransvectionStruct n R), Commute t.toMatrix M
⊢ M ∈ Set.range ⇑(scalar n)
state_after: n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝⁴ : Field 𝕜
inst✝³ : DecidableEq n
inst✝² : DecidableEq p
inst✝¹ : CommRing R
i j : n
inst✝ : Fintype n
M : Matrix n n R
hM : ∀ (t : TransvectionStruct n R), Commute t.toMatrix M
⊢ Pairwise fun i j => Commute (stdBasisMatrix i j 1) M

tactic: intro i j hij
state_before: n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝⁴ : Field 𝕜
inst✝³ : DecidableEq n
inst✝² : DecidableEq p
inst✝¹ : CommRing R
i j : n
inst✝ : Fintype n
M : Matrix n n R
hM : ∀ (t : TransvectionStruct n R), Commute t.toMatrix M
⊢ Pairwise fun i j => Commute (stdBasisMatrix i j 1) M
state_after: n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝⁴ : Field 𝕜
inst✝³ : DecidableEq n
inst✝² : DecidableEq p
inst✝¹ : CommRing R
i✝ j✝ : n
inst✝ : Fintype n
M : Matrix n n R
hM : ∀ (t : TransvectionStruct n R), Commute t.toMatrix M
i j : n
hij : i ≠ j
⊢ Commute (stdBasisMatrix i j 1) M

tactic: simpa [transvection, mul_add, add_mul] using (hM ⟨i, j, hij, 1⟩).eq
state_before: n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝⁴ : Field 𝕜
inst✝³ : DecidableEq n
inst✝² : DecidableEq p
inst✝¹ : CommRing R
i✝ j✝ : n
inst✝ : Fintype n
M : Matrix n n R
hM : ∀ (t : TransvectionStruct n R), Commute t.toMatrix M
i j : n
hij : i ≠ j
⊢ Commute (stdBasisMatrix i j 1) M
state_after: no goals
Theorem: SimpleGraph.induceHom_id
File: Mathlib/Combinatorics/SimpleGraph/Maps.lean

tactic: ext x
state_before: V : Type u_1
W : Type u_2
X : Type u_3
G✝ : SimpleGraph V
G' : SimpleGraph W
u v : V
G'' : SimpleGraph X
s✝ : Set V
t : Set W
r : Set X
φ : G✝ →g G'
φst : Set.MapsTo (⇑φ) s✝ t
ψ : G' →g G''
ψtr : Set.MapsTo (⇑ψ) t r
G : SimpleGraph V
s : Set V
⊢ induceHom Hom.id ⋯ = Hom.id
state_after: case h.a
V : Type u_1
W : Type u_2
X : Type u_3
G✝ : SimpleGraph V
G' : SimpleGraph W
u v : V
G'' : SimpleGraph X
s✝ : Set V
t : Set W
r : Set X
φ : G✝ →g G'
φst : Set.MapsTo (⇑φ) s✝ t
ψ : G' →g G''
ψtr : Set.MapsTo (⇑ψ) t r
G : SimpleGraph V
s : Set V
x : ↑s
⊢ ↑((induceHom Hom.id ⋯) x) = ↑(Hom.id x)

tactic: rfl
state_before: case h.a
V : Type u_1
W : Type u_2
X : Type u_3
G✝ : SimpleGraph V
G' : SimpleGraph W
u v : V
G'' : SimpleGraph X
s✝ : Set V
t : Set W
r : Set X
φ : G✝ →g G'
φst : Set.MapsTo (⇑φ) s✝ t
ψ : G' →g G''
ψtr : Set.MapsTo (⇑ψ) t r
G : SimpleGraph V
s : Set V
x : ↑s
⊢ ↑((induceHom Hom.id ⋯) x) = ↑(Hom.id x)
state_after: no goals
Theorem: Function.Commute.comp_iterate
File: Mathlib/Logic/Function/Iterate.lean

tactic: induction n with
| zero => rfl
| succ n ihn =>
  funext x
  simp only [ihn, (h.iterate_right n).eq, iterate_succ, comp_apply]
state_before: α : Type u
β : Type v
f g : α → α
h : Commute f g
n : ℕ
⊢ (f ∘ g)^[n] = f^[n] ∘ g^[n]
state_after: no goals

tactic: rfl
state_before: case zero
α : Type u
β : Type v
f g : α → α
h : Commute f g
⊢ (f ∘ g)^[0] = f^[0] ∘ g^[0]
state_after: no goals

tactic: funext x
state_before: case succ
α : Type u
β : Type v
f g : α → α
h : Commute f g
n : ℕ
ihn : (f ∘ g)^[n] = f^[n] ∘ g^[n]
⊢ (f ∘ g)^[n + 1] = f^[n + 1] ∘ g^[n + 1]
state_after: case succ.h
α : Type u
β : Type v
f g : α → α
h : Commute f g
n : ℕ
ihn : (f ∘ g)^[n] = f^[n] ∘ g^[n]
x : α
⊢ (f ∘ g)^[n + 1] x = (f^[n + 1] ∘ g^[n + 1]) x

tactic: simp only [ihn, (h.iterate_right n).eq, iterate_succ, comp_apply]
state_before: case succ.h
α : Type u
β : Type v
f g : α → α
h : Commute f g
n : ℕ
ihn : (f ∘ g)^[n] = f^[n] ∘ g^[n]
x : α
⊢ (f ∘ g)^[n + 1] x = (f^[n + 1] ∘ g^[n + 1]) x
state_after: no goals
Theorem: map_invOf
File: Mathlib/Algebra/Group/Invertible/Basic.lean

tactic: subst h
state_before: α : Type u
R : Type u_1
S : Type u_2
F : Type u_3
inst✝⁴ : MulOneClass R
inst✝³ : Monoid S
inst✝² : FunLike F R S
inst✝¹ : MonoidHomClass F R S
f : F
r : R
inst✝ : Invertible r
ifr : Invertible (f r)
h : ifr = Invertible.map f r
⊢ f ⅟r = ⅟(f r)
state_after: α : Type u
R : Type u_1
S : Type u_2
F : Type u_3
inst✝⁴ : MulOneClass R
inst✝³ : Monoid S
inst✝² : FunLike F R S
inst✝¹ : MonoidHomClass F R S
f : F
r : R
inst✝ : Invertible r
⊢ f ⅟r = ⅟(f r)

tactic: rfl
state_before: α : Type u
R : Type u_1
S : Type u_2
F : Type u_3
inst✝⁴ : MulOneClass R
inst✝³ : Monoid S
inst✝² : FunLike F R S
inst✝¹ : MonoidHomClass F R S
f : F
r : R
inst✝ : Invertible r
⊢ f ⅟r = ⅟(f r)
state_after: no goals
Theorem: MeasureTheory.FiniteMeasure.smul_testAgainstNN_apply
File: Mathlib/MeasureTheory/Measure/FiniteMeasure.lean

tactic: simp only [testAgainstNN, toMeasure_smul, smul_eq_mul, ← ENNReal.smul_toNNReal, ENNReal.smul_def,
  lintegral_smul_measure]
state_before: Ω : Type u_1
inst✝⁵ : MeasurableSpace Ω
R : Type u_2
inst✝⁴ : SMul R ℝ≥0
inst✝³ : SMul R ℝ≥0∞
inst✝² : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝¹ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
inst✝ : TopologicalSpace Ω
c : ℝ≥0
μ : FiniteMeasure Ω
f : Ω →ᵇ ℝ≥0
⊢ (c • μ).testAgainstNN f = c • μ.testAgainstNN f
state_after: no goals