1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Group.card_center_add_sum_card_noncenter_eq_card
File: Mathlib/GroupTheory/ClassEquation.lean

tactic: convert Group.nat_card_center_add_sum_card_noncenter_eq_card G using 2
state_before: G✝ : Type u_1
inst✝⁵ : Group G✝
G : Type u_2
inst✝⁴ : Group G
inst✝³ : (x : ConjClasses G) → Fintype ↑x.carrier
inst✝² : Fintype G
inst✝¹ : Fintype ↥(Subgroup.center G)
inst✝ : Fintype ↑(noncenter G)
⊢ Fintype.card ↥(Subgroup.center G) + ∑ x ∈ (noncenter G).toFinset, x.carrier.toFinset.card = Fintype.card G
state_after: case h.e'_2.h.e'_5
G✝ : Type u_1
inst✝⁵ : Group G✝
G : Type u_2
inst✝⁴ : Group G
inst✝³ : (x : ConjClasses G) → Fintype ↑x.carrier
inst✝² : Fintype G
inst✝¹ : Fintype ↥(Subgroup.center G)
inst✝ : Fintype ↑(noncenter G)
⊢ Fintype.card ↥(Subgroup.center G) = Nat.card ↥(Subgroup.center G)

case h.e'_2.h.e'_6
G✝ : Type u_1
inst✝⁵ : Group G✝
G : Type u_2
inst✝⁴ : Group G
inst✝³ : (x : ConjClasses G) → Fintype ↑x.carrier
inst✝² : Fintype G
inst✝¹ : Fintype ↥(Subgroup.center G)
inst✝ : Fintype ↑(noncenter G)
⊢ ∑ x ∈ (noncenter G).toFinset, x.carrier.toFinset.card =
    ∑ᶠ (x : ConjClasses G) (_ : x ∈ noncenter G), Nat.card ↑x.carrier

case h.e'_3
G✝ : Type u_1
inst✝⁵ : Group G✝
G : Type u_2
inst✝⁴ : Group G
inst✝³ : (x : ConjClasses G) → Fintype ↑x.carrier
inst✝² : Fintype G
inst✝¹ : Fintype ↥(Subgroup.center G)
inst✝ : Fintype ↑(noncenter G)
⊢ Fintype.card G = Nat.card G

tactic: simp
state_before: case h.e'_2.h.e'_5
G✝ : Type u_1
inst✝⁵ : Group G✝
G : Type u_2
inst✝⁴ : Group G
inst✝³ : (x : ConjClasses G) → Fintype ↑x.carrier
inst✝² : Fintype G
inst✝¹ : Fintype ↥(Subgroup.center G)
inst✝ : Fintype ↑(noncenter G)
⊢ Fintype.card ↥(Subgroup.center G) = Nat.card ↥(Subgroup.center G)
state_after: no goals

tactic: rw [← finsum_set_coe_eq_finsum_mem (noncenter G), finsum_eq_sum_of_fintype,
  ← Finset.sum_set_coe]
state_before: case h.e'_2.h.e'_6
G✝ : Type u_1
inst✝⁵ : Group G✝
G : Type u_2
inst✝⁴ : Group G
inst✝³ : (x : ConjClasses G) → Fintype ↑x.carrier
inst✝² : Fintype G
inst✝¹ : Fintype ↥(Subgroup.center G)
inst✝ : Fintype ↑(noncenter G)
⊢ ∑ x ∈ (noncenter G).toFinset, x.carrier.toFinset.card =
    ∑ᶠ (x : ConjClasses G) (_ : x ∈ noncenter G), Nat.card ↑x.carrier
state_after: case h.e'_2.h.e'_6
G✝ : Type u_1
inst✝⁵ : Group G✝
G : Type u_2
inst✝⁴ : Group G
inst✝³ : (x : ConjClasses G) → Fintype ↑x.carrier
inst✝² : Fintype G
inst✝¹ : Fintype ↥(Subgroup.center G)
inst✝ : Fintype ↑(noncenter G)
⊢ ∑ i : ↑(noncenter G), (↑i).carrier.toFinset.card = ∑ i : ↑(noncenter G), Nat.card ↑(↑i).carrier

tactic: simp
state_before: case h.e'_2.h.e'_6
G✝ : Type u_1
inst✝⁵ : Group G✝
G : Type u_2
inst✝⁴ : Group G
inst✝³ : (x : ConjClasses G) → Fintype ↑x.carrier
inst✝² : Fintype G
inst✝¹ : Fintype ↥(Subgroup.center G)
inst✝ : Fintype ↑(noncenter G)
⊢ ∑ i : ↑(noncenter G), (↑i).carrier.toFinset.card = ∑ i : ↑(noncenter G), Nat.card ↑(↑i).carrier
state_after: no goals

tactic: simp
state_before: case h.e'_3
G✝ : Type u_1
inst✝⁵ : Group G✝
G : Type u_2
inst✝⁴ : Group G
inst✝³ : (x : ConjClasses G) → Fintype ↑x.carrier
inst✝² : Fintype G
inst✝¹ : Fintype ↥(Subgroup.center G)
inst✝ : Fintype ↑(noncenter G)
⊢ Fintype.card G = Nat.card G
state_after: no goals
Theorem: Con.sInf_toSetoid
File: Mathlib/GroupTheory/Congruence/Basic.lean

tactic: rw [← hr]
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c✝ : Con M
S : Set (Con M)
x y : M
h : (sInf S).Rel x y
r : Setoid M
x✝ : r ∈ toSetoid '' S
c : Con M
hS : c ∈ S
hr : c.toSetoid = r
⊢ r.Rel x y
state_after: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c✝ : Con M
S : Set (Con M)
x y : M
h : (sInf S).Rel x y
r : Setoid M
x✝ : r ∈ toSetoid '' S
c : Con M
hS : c ∈ S
hr : c.toSetoid = r
⊢ c.Rel x y

tactic: exact h c hS
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c✝ : Con M
S : Set (Con M)
x y : M
h : (sInf S).Rel x y
r : Setoid M
x✝ : r ∈ toSetoid '' S
c : Con M
hS : c ∈ S
hr : c.toSetoid = r
⊢ c.Rel x y
state_after: no goals
Theorem: MvPowerSeries.coeff_monomial_mul
File: Mathlib/RingTheory/MvPowerSeries/Basic.lean

tactic: classical
have :
  ∀ p ∈ antidiagonal m,
    coeff R (p : (σ →₀ ℕ) × (σ →₀ ℕ)).1 (monomial R n a) * coeff R p.2 φ ≠ 0 → p.1 = n :=
  fun p _ hp => eq_of_coeff_monomial_ne_zero (left_ne_zero_of_mul hp)
rw [coeff_mul, ← Finset.sum_filter_of_ne this, Finset.filter_fst_eq_antidiagonal _ n,
  Finset.sum_ite_index]
simp only [Finset.sum_singleton, coeff_monomial_same, Finset.sum_empty]
state_before: σ : Type u_1
R : Type u_2
inst✝ : Semiring R
m n : σ →₀ ℕ
φ ψ : MvPowerSeries σ R
a : R
⊢ (coeff R m) ((monomial R n) a * φ) = if n ≤ m then a * (coeff R (m - n)) φ else 0
state_after: no goals

tactic: have :
  ∀ p ∈ antidiagonal m,
    coeff R (p : (σ →₀ ℕ) × (σ →₀ ℕ)).1 (monomial R n a) * coeff R p.2 φ ≠ 0 → p.1 = n :=
  fun p _ hp => eq_of_coeff_monomial_ne_zero (left_ne_zero_of_mul hp)
state_before: σ : Type u_1
R : Type u_2
inst✝ : Semiring R
m n : σ →₀ ℕ
φ ψ : MvPowerSeries σ R
a : R
⊢ (coeff R m) ((monomial R n) a * φ) = if n ≤ m then a * (coeff R (m - n)) φ else 0
state_after: σ : Type u_1
R : Type u_2
inst✝ : Semiring R
m n : σ →₀ ℕ
φ ψ : MvPowerSeries σ R
a : R
this : ∀ p ∈ antidiagonal m, (coeff R p.1) ((monomial R n) a) * (coeff R p.2) φ ≠ 0 → p.1 = n
⊢ (coeff R m) ((monomial R n) a * φ) = if n ≤ m then a * (coeff R (m - n)) φ else 0

tactic: rw [coeff_mul, ← Finset.sum_filter_of_ne this, Finset.filter_fst_eq_antidiagonal _ n,
  Finset.sum_ite_index]
state_before: σ : Type u_1
R : Type u_2
inst✝ : Semiring R
m n : σ →₀ ℕ
φ ψ : MvPowerSeries σ R
a : R
this : ∀ p ∈ antidiagonal m, (coeff R p.1) ((monomial R n) a) * (coeff R p.2) φ ≠ 0 → p.1 = n
⊢ (coeff R m) ((monomial R n) a * φ) = if n ≤ m then a * (coeff R (m - n)) φ else 0
state_after: σ : Type u_1
R : Type u_2
inst✝ : Semiring R
m n : σ →₀ ℕ
φ ψ : MvPowerSeries σ R
a : R
this : ∀ p ∈ antidiagonal m, (coeff R p.1) ((monomial R n) a) * (coeff R p.2) φ ≠ 0 → p.1 = n
⊢ (if n ≤ m then ∑ x ∈ {(n, m - n)}, (coeff R x.1) ((monomial R n) a) * (coeff R x.2) φ
    else ∑ x ∈ ∅, (coeff R x.1) ((monomial R n) a) * (coeff R x.2) φ) =
    if n ≤ m then a * (coeff R (m - n)) φ else 0

tactic: simp only [Finset.sum_singleton, coeff_monomial_same, Finset.sum_empty]
state_before: σ : Type u_1
R : Type u_2
inst✝ : Semiring R
m n : σ →₀ ℕ
φ ψ : MvPowerSeries σ R
a : R
this : ∀ p ∈ antidiagonal m, (coeff R p.1) ((monomial R n) a) * (coeff R p.2) φ ≠ 0 → p.1 = n
⊢ (if n ≤ m then ∑ x ∈ {(n, m - n)}, (coeff R x.1) ((monomial R n) a) * (coeff R x.2) φ
    else ∑ x ∈ ∅, (coeff R x.1) ((monomial R n) a) * (coeff R x.2) φ) =
    if n ≤ m then a * (coeff R (m - n)) φ else 0
state_after: no goals
Theorem: ProbabilityTheory.lintegral_stieltjesOfMeasurableRat
File: Mathlib/Probability/Kernel/Disintegration/CdfToKernel.lean

tactic: rw [← setLIntegral_univ, setLIntegral_stieltjesOfMeasurableRat hf _ _ MeasurableSet.univ]
state_before: α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : ↥(kernel α (β × ℝ))
ν : ↥(kernel α β)
f : α × β → ℚ → ℝ
inst✝ : IsFiniteKernel κ
hf : IsRatCondKernelCDF f κ ν
a : α
x : ℝ
⊢ ∫⁻ (b : β), ENNReal.ofReal (↑(stieltjesOfMeasurableRat f ⋯ (a, b)) x) ∂ν a = (κ a) (univ ×ˢ Iic x)
state_after: no goals
Theorem: MeasureTheory.Integrable.abs
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: rw [← memℒp_one_iff_integrable] at hf ⊢
state_before: α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : MeasurableSpace δ
inst✝² : NormedAddCommGroup β✝
inst✝¹ : NormedAddCommGroup γ
β : Type u_5
inst✝ : NormedLatticeAddCommGroup β
f : α → β
hf : Integrable f μ
⊢ Integrable (fun a => |f a|) μ
state_after: α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : MeasurableSpace δ
inst✝² : NormedAddCommGroup β✝
inst✝¹ : NormedAddCommGroup γ
β : Type u_5
inst✝ : NormedLatticeAddCommGroup β
f : α → β
hf : Memℒp f 1 μ
⊢ Memℒp (fun a => |f a|) 1 μ

tactic: exact hf.abs
state_before: α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : MeasurableSpace δ
inst✝² : NormedAddCommGroup β✝
inst✝¹ : NormedAddCommGroup γ
β : Type u_5
inst✝ : NormedLatticeAddCommGroup β
f : α → β
hf : Memℒp f 1 μ
⊢ Memℒp (fun a => |f a|) 1 μ
state_after: no goals
Theorem: AkraBazziRecurrence.GrowsPolynomially.of_isEquivalent
File: Mathlib/Computability/AkraBazzi/GrowsPolynomially.lean

tactic: have : f = g + (f - g) := by ext; simp
state_before: f✝ f g : ℝ → ℝ
hg : GrowsPolynomially g
hf : f ~[atTop] g
⊢ GrowsPolynomially f
state_after: f✝ f g : ℝ → ℝ
hg : GrowsPolynomially g
hf : f ~[atTop] g
this : f = g + (f - g)
⊢ GrowsPolynomially f

tactic: rw [this]
state_before: f✝ f g : ℝ → ℝ
hg : GrowsPolynomially g
hf : f ~[atTop] g
this : f = g + (f - g)
⊢ GrowsPolynomially f
state_after: f✝ f g : ℝ → ℝ
hg : GrowsPolynomially g
hf : f ~[atTop] g
this : f = g + (f - g)
⊢ GrowsPolynomially (g + (f - g))

tactic: exact add_isLittleO hg hf
state_before: f✝ f g : ℝ → ℝ
hg : GrowsPolynomially g
hf : f ~[atTop] g
this : f = g + (f - g)
⊢ GrowsPolynomially (g + (f - g))
state_after: no goals

tactic: ext
state_before: f✝ f g : ℝ → ℝ
hg : GrowsPolynomially g
hf : f ~[atTop] g
⊢ f = g + (f - g)
state_after: case h
f✝ f g : ℝ → ℝ
hg : GrowsPolynomially g
hf : f ~[atTop] g
x✝ : ℝ
⊢ f x✝ = (g + (f - g)) x✝

tactic: simp
state_before: case h
f✝ f g : ℝ → ℝ
hg : GrowsPolynomially g
hf : f ~[atTop] g
x✝ : ℝ
⊢ f x✝ = (g + (f - g)) x✝
state_after: no goals
Theorem: Commute.pow_dvd_pow_of_sub_pow_eq_zero
File: Mathlib/Algebra/Ring/Divisibility/Lemmas.lean

tactic: rw [← sub_add_cancel y x]
state_before: R : Type u_1
x y : R
n m p : ℕ
hp : n + m ≤ p + 1
inst✝ : Ring R
h_comm : Commute x y
h : (x - y) ^ n = 0
⊢ x ^ m ∣ y ^ p
state_after: R : Type u_1
x y : R
n m p : ℕ
hp : n + m ≤ p + 1
inst✝ : Ring R
h_comm : Commute x y
h : (x - y) ^ n = 0
⊢ x ^ m ∣ (y - x + x) ^ p

tactic: apply (h_comm.symm.sub_left rfl).pow_dvd_add_pow_of_pow_eq_zero_left hp _
state_before: R : Type u_1
x y : R
n m p : ℕ
hp : n + m ≤ p + 1
inst✝ : Ring R
h_comm : Commute x y
h : (x - y) ^ n = 0
⊢ x ^ m ∣ (y - x + x) ^ p
state_after: R : Type u_1
x y : R
n m p : ℕ
hp : n + m ≤ p + 1
inst✝ : Ring R
h_comm : Commute x y
h : (x - y) ^ n = 0
⊢ (y - x) ^ n = 0

tactic: rw [← neg_sub x y, neg_pow, h, mul_zero]
state_before: R : Type u_1
x y : R
n m p : ℕ
hp : n + m ≤ p + 1
inst✝ : Ring R
h_comm : Commute x y
h : (x - y) ^ n = 0
⊢ (y - x) ^ n = 0
state_after: no goals
Theorem: Submodule.cardQuot_eq_one_iff
File: Mathlib/RingTheory/Ideal/Norm.lean

tactic: simp [SetLike.ext_iff]
state_before: R : Type u_1
M : Type u_2
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
P : Submodule R M
⊢ P.toAddSubgroup = ⊤ ↔ P = ⊤
state_after: no goals
Theorem: StarConvex.smul_mem
File: Mathlib/Analysis/Convex/Star.lean

tactic: simpa using hs.add_smul_mem (by simpa using hx) ht₀ ht₁
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y : E
s t✝ : Set E
hs : StarConvex 𝕜 0 s
hx : x ∈ s
t : 𝕜
ht₀ : 0 ≤ t
ht₁ : t ≤ 1
⊢ t • x ∈ s
state_after: no goals

tactic: simpa using hx
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y : E
s t✝ : Set E
hs : StarConvex 𝕜 0 s
hx : x ∈ s
t : 𝕜
ht₀ : 0 ≤ t
ht₁ : t ≤ 1
⊢ 0 + x ∈ s
state_after: no goals
Theorem: CliffordAlgebra.contractLeft_ι_mul
File: Mathlib/LinearAlgebra/CliffordAlgebra/Contraction.lean

tactic: refine foldr'_ι_mul _ _ ?_ _ _ _
state_before: R : Type u1
inst✝² : CommRing R
M : Type u2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
d d' : Module.Dual R M
a : M
b : CliffordAlgebra Q
⊢ (contractLeft d) ((ι Q) a * b) = d a • b - (ι Q) a * (contractLeft d) b
state_after: R : Type u1
inst✝² : CommRing R
M : Type u2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
d d' : Module.Dual R M
a : M
b : CliffordAlgebra Q
⊢ ∀ (m : M) (x fx : CliffordAlgebra Q),
    ((contractLeftAux Q d) m) ((ι Q) m * x, ((contractLeftAux Q d) m) (x, fx)) = Q m • fx

tactic: exact fun m x fx ↦ contractLeftAux_contractLeftAux Q d m x fx
state_before: R : Type u1
inst✝² : CommRing R
M : Type u2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
d d' : Module.Dual R M
a : M
b : CliffordAlgebra Q
⊢ ∀ (m : M) (x fx : CliffordAlgebra Q),
    ((contractLeftAux Q d) m) ((ι Q) m * x, ((contractLeftAux Q d) m) (x, fx)) = Q m • fx
state_after: no goals
Theorem: MonoidAlgebra.support_single_mul
File: Mathlib/Algebra/MonoidAlgebra/Support.lean

tactic: classical
  ext
  simp only [support_single_mul_eq_image f hr (IsLeftRegular.all x), mem_image,
    mem_map, mulLeftEmbedding_apply]
state_before: k : Type u₁
G : Type u₂
inst✝² : Semiring k
inst✝¹ : Mul G
inst✝ : IsLeftCancelMul G
f : MonoidAlgebra k G
r : k
hr : ∀ (y : k), r * y = 0 ↔ y = 0
x : G
⊢ (single x r * f).support = map (mulLeftEmbedding x) f.support
state_after: no goals

tactic: ext
state_before: k : Type u₁
G : Type u₂
inst✝² : Semiring k
inst✝¹ : Mul G
inst✝ : IsLeftCancelMul G
f : MonoidAlgebra k G
r : k
hr : ∀ (y : k), r * y = 0 ↔ y = 0
x : G
⊢ (single x r * f).support = map (mulLeftEmbedding x) f.support
state_after: case a
k : Type u₁
G : Type u₂
inst✝² : Semiring k
inst✝¹ : Mul G
inst✝ : IsLeftCancelMul G
f : MonoidAlgebra k G
r : k
hr : ∀ (y : k), r * y = 0 ↔ y = 0
x a✝ : G
⊢ a✝ ∈ (single x r * f).support ↔ a✝ ∈ map (mulLeftEmbedding x) f.support

tactic: simp only [support_single_mul_eq_image f hr (IsLeftRegular.all x), mem_image,
  mem_map, mulLeftEmbedding_apply]
state_before: case a
k : Type u₁
G : Type u₂
inst✝² : Semiring k
inst✝¹ : Mul G
inst✝ : IsLeftCancelMul G
f : MonoidAlgebra k G
r : k
hr : ∀ (y : k), r * y = 0 ↔ y = 0
x a✝ : G
⊢ a✝ ∈ (single x r * f).support ↔ a✝ ∈ map (mulLeftEmbedding x) f.support
state_after: no goals
Theorem: ZMod.valMinAbs_def_pos
File: Mathlib/Data/ZMod/Basic.lean

tactic: cases n
state_before: n : ℕ
inst✝ : NeZero n
x : ZMod n
⊢ x.valMinAbs = if x.val ≤ n / 2 then ↑x.val else ↑x.val - ↑n
state_after: case zero
inst✝ : NeZero 0
x : ZMod 0
⊢ x.valMinAbs = if x.val ≤ 0 / 2 then ↑x.val else ↑x.val - ↑0

case succ
n✝ : ℕ
inst✝ : NeZero (n✝ + 1)
x : ZMod (n✝ + 1)
⊢ x.valMinAbs = if x.val ≤ (n✝ + 1) / 2 then ↑x.val else ↑x.val - ↑(n✝ + 1)

tactic: cases NeZero.ne 0 rfl
state_before: case zero
inst✝ : NeZero 0
x : ZMod 0
⊢ x.valMinAbs = if x.val ≤ 0 / 2 then ↑x.val else ↑x.val - ↑0
state_after: no goals

tactic: rfl
state_before: case succ
n✝ : ℕ
inst✝ : NeZero (n✝ + 1)
x : ZMod (n✝ + 1)
⊢ x.valMinAbs = if x.val ≤ (n✝ + 1) / 2 then ↑x.val else ↑x.val - ↑(n✝ + 1)
state_after: no goals
Theorem: Batteries.RBNode.reverse_eq_iff
File: .lake/packages/batteries/Batteries/Data/RBMap/WF.lean

tactic: constructor <;> rintro rfl <;> simp
state_before: α : Type u_1
t t' : RBNode α
⊢ t.reverse = t' ↔ t = t'.reverse
state_after: no goals
Theorem: Hindman.FP.singleton
File: Mathlib/Combinatorics/Hindman.lean

tactic: induction' i with i ih generalizing a
state_before: M : Type u_1
inst✝ : Semigroup M
a : Stream' M
i : ℕ
⊢ a.get i ∈ FP a
state_after: case zero
M : Type u_1
inst✝ : Semigroup M
a : Stream' M
⊢ a.get 0 ∈ FP a

case succ
M : Type u_1
inst✝ : Semigroup M
i : ℕ
ih : ∀ (a : Stream' M), a.get i ∈ FP a
a : Stream' M
⊢ a.get (i + 1) ∈ FP a

tactic: apply FP.head
state_before: case zero
M : Type u_1
inst✝ : Semigroup M
a : Stream' M
⊢ a.get 0 ∈ FP a
state_after: no goals

tactic: apply FP.tail
state_before: case succ
M : Type u_1
inst✝ : Semigroup M
i : ℕ
ih : ∀ (a : Stream' M), a.get i ∈ FP a
a : Stream' M
⊢ a.get (i + 1) ∈ FP a
state_after: case succ.h
M : Type u_1
inst✝ : Semigroup M
i : ℕ
ih : ∀ (a : Stream' M), a.get i ∈ FP a
a : Stream' M
⊢ FP a.tail (a.get (i + 1))

tactic: apply ih
state_before: case succ.h
M : Type u_1
inst✝ : Semigroup M
i : ℕ
ih : ∀ (a : Stream' M), a.get i ∈ FP a
a : Stream' M
⊢ FP a.tail (a.get (i + 1))
state_after: no goals
Theorem: OptionT.run_map
File: Mathlib/Init/Control/Lawful.lean

tactic: rw [← bind_pure_comp _ x.run]
state_before: α β : Type u
m : Type u → Type v
x : OptionT m α
inst✝¹ : Monad m
f : α → β
inst✝ : LawfulMonad m
⊢ (f <$> x).run = Option.map f <$> x.run
state_after: α β : Type u
m : Type u → Type v
x : OptionT m α
inst✝¹ : Monad m
f : α → β
inst✝ : LawfulMonad m
⊢ (f <$> x).run = do
    let a ← x.run
    pure (Option.map f a)

tactic: change x.run >>= (fun
                   | some a => OptionT.run (pure (f a))
                   | none   => pure none) = _
state_before: α β : Type u
m : Type u → Type v
x : OptionT m α
inst✝¹ : Monad m
f : α → β
inst✝ : LawfulMonad m
⊢ (f <$> x).run = do
    let a ← x.run
    pure (Option.map f a)
state_after: α β : Type u
m : Type u → Type v
x : OptionT m α
inst✝¹ : Monad m
f : α → β
inst✝ : LawfulMonad m
⊢ (do
      let x ← x.run
      match x with
        | some a => (pure (f a)).run
        | none => pure none) =
    do
    let a ← x.run
    pure (Option.map f a)

tactic: apply bind_congr
state_before: α β : Type u
m : Type u → Type v
x : OptionT m α
inst✝¹ : Monad m
f : α → β
inst✝ : LawfulMonad m
⊢ (do
      let x ← x.run
      match x with
        | some a => (pure (f a)).run
        | none => pure none) =
    do
    let a ← x.run
    pure (Option.map f a)
state_after: case h
α β : Type u
m : Type u → Type v
x : OptionT m α
inst✝¹ : Monad m
f : α → β
inst✝ : LawfulMonad m
⊢ ∀ (a : Option α),
    (match a with
      | some a => (pure (f a)).run
      | none => pure none) =
      pure (Option.map f a)

tactic: intro a
state_before: case h
α β : Type u
m : Type u → Type v
x : OptionT m α
inst✝¹ : Monad m
f : α → β
inst✝ : LawfulMonad m
⊢ ∀ (a : Option α),
    (match a with
      | some a => (pure (f a)).run
      | none => pure none) =
      pure (Option.map f a)
state_after: case h
α β : Type u
m : Type u → Type v
x : OptionT m α
inst✝¹ : Monad m
f : α → β
inst✝ : LawfulMonad m
a : Option α
⊢ (match a with
    | some a => (pure (f a)).run
    | none => pure none) =
    pure (Option.map f a)

tactic: cases a <;> simp [Option.map, Option.bind]
state_before: case h
α β : Type u
m : Type u → Type v
x : OptionT m α
inst✝¹ : Monad m
f : α → β
inst✝ : LawfulMonad m
a : Option α
⊢ (match a with
    | some a => (pure (f a)).run
    | none => pure none) =
    pure (Option.map f a)
state_after: no goals
Theorem: Fintype.piFinset_of_isEmpty
File: Mathlib/Data/Fintype/Pi.lean

tactic: simp
state_before: α : Type u_1
inst✝² : DecidableEq α
inst✝¹ : Fintype α
γ : α → Type u_2
δ : α → Type u_3
s✝ : (a : α) → Finset (γ a)
inst✝ : IsEmpty α
s : (a : α) → Finset (γ a)
x✝ : (a : α) → γ a
⊢ x✝ ∈ piFinset s
state_after: no goals
Theorem: Bool.not_iff_not
File: Mathlib/Data/Bool/Basic.lean

tactic: simp
state_before: ⊢ ∀ {b : Bool}, (!b) = true ↔ ¬b = true
state_after: no goals
Theorem: Ordinal.CNFRec_pos
File: Mathlib/SetTheory/Ordinal/CantorNormalForm.lean

tactic: rw [CNFRec, dif_neg ho]
state_before: b o : Ordinal.{u_2}
C : Ordinal.{u_2} → Sort u_1
ho : o ≠ 0
H0 : C 0
H : (o : Ordinal.{u_2}) → o ≠ 0 → C (o % b ^ log b o) → C o
⊢ b.CNFRec H0 H o = H o ho (b.CNFRec H0 H (o % b ^ log b o))
state_after: no goals
Theorem: AlgebraicGeometry.ProjIsoSpecTopComponent.toSpec_injective
File: Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Scheme.lean

tactic: intro x₁ x₂ h
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
m : ℕ
f_deg : f ∈ 𝒜 m
hm : 0 < m
⊢ Function.Injective ⇑(toSpec 𝒜 f)
state_after: R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
m : ℕ
f_deg : f ∈ 𝒜 m
hm : 0 < m
x₁ x₂ : ↑↑(Proj.restrict ⋯).toPresheafedSpace
h : (toSpec 𝒜 f) x₁ = (toSpec 𝒜 f) x₂
⊢ x₁ = x₂

tactic: have := congr_arg (FromSpec.toFun f_deg hm) h
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
m : ℕ
f_deg : f ∈ 𝒜 m
hm : 0 < m
x₁ x₂ : ↑↑(Proj.restrict ⋯).toPresheafedSpace
h : (toSpec 𝒜 f) x₁ = (toSpec 𝒜 f) x₂
⊢ x₁ = x₂
state_after: R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
m : ℕ
f_deg : f ∈ 𝒜 m
hm : 0 < m
x₁ x₂ : ↑↑(Proj.restrict ⋯).toPresheafedSpace
h : (toSpec 𝒜 f) x₁ = (toSpec 𝒜 f) x₂
this : FromSpec.toFun f_deg hm ((toSpec 𝒜 f) x₁) = FromSpec.toFun f_deg hm ((toSpec 𝒜 f) x₂)
⊢ x₁ = x₂

tactic: rwa [fromSpec_toSpec, fromSpec_toSpec] at this
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
m : ℕ
f_deg : f ∈ 𝒜 m
hm : 0 < m
x₁ x₂ : ↑↑(Proj.restrict ⋯).toPresheafedSpace
h : (toSpec 𝒜 f) x₁ = (toSpec 𝒜 f) x₂
this : FromSpec.toFun f_deg hm ((toSpec 𝒜 f) x₁) = FromSpec.toFun f_deg hm ((toSpec 𝒜 f) x₂)
⊢ x₁ = x₂
state_after: no goals
Theorem: Subfield.mem_closure_iff
File: Mathlib/Algebra/Field/Subfield.lean

tactic: rw [← commClosure_eq_closure]
state_before: K✝ : Type u
L : Type v
M : Type w
inst✝³ : DivisionRing K✝
inst✝² : DivisionRing L
inst✝¹ : DivisionRing M
s✝¹ : Set K✝
K : Type u
inst✝ : Field K
s✝ : Subfield K
s : Set K
x : K
⊢ x ∈ closure s ↔ ∃ y ∈ Subring.closure s, ∃ z ∈ Subring.closure s, y / z = x
state_after: K✝ : Type u
L : Type v
M : Type w
inst✝³ : DivisionRing K✝
inst✝² : DivisionRing L
inst✝¹ : DivisionRing M
s✝¹ : Set K✝
K : Type u
inst✝ : Field K
s✝ : Subfield K
s : Set K
x : K
⊢ x ∈ Subfield.commClosure s ↔ ∃ y ∈ Subring.closure s, ∃ z ∈ Subring.closure s, y / z = x

tactic: rfl
state_before: K✝ : Type u
L : Type v
M : Type w
inst✝³ : DivisionRing K✝
inst✝² : DivisionRing L
inst✝¹ : DivisionRing M
s✝¹ : Set K✝
K : Type u
inst✝ : Field K
s✝ : Subfield K
s : Set K
x : K
⊢ x ∈ Subfield.commClosure s ↔ ∃ y ∈ Subring.closure s, ∃ z ∈ Subring.closure s, y / z = x
state_after: no goals
Theorem: finrank_span_le_card
File: Mathlib/LinearAlgebra/Dimension/Constructions.lean

tactic: simpa using rank_span_le (R := R) s
state_before: R S : Type u
M : Type v
M' : Type v'
M₁ : Type v
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝⁹ : Ring R
inst✝⁸ : CommRing S
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M₁
inst✝¹ : StrongRankCondition R
s : Set M
inst✝ : Fintype ↑s
⊢ Module.rank R ↥(span R s) ≤ ↑s.toFinset.card
state_after: no goals
Theorem: HomotopyGroup.inv_spec
File: Mathlib/Topology/Homotopy/HomotopyGroup.lean

tactic: rw [symmAt_indep (Classical.arbitrary N) p, ← fromLoop_symm_toLoop]
state_before: N : Type u_1
X : Type u_2
inst✝² : TopologicalSpace X
x : X
inst✝¹ : DecidableEq N
inst✝ : Nonempty N
i : N
p : ↑(Ω^ N X x)
⊢ (⟦p⟧)⁻¹ = ⟦symmAt i p⟧
state_after: N : Type u_1
X : Type u_2
inst✝² : TopologicalSpace X
x : X
inst✝¹ : DecidableEq N
inst✝ : Nonempty N
i : N
p : ↑(Ω^ N X x)
⊢ (⟦p⟧)⁻¹ = ⟦fromLoop (Classical.arbitrary N) (Path.symm (toLoop (Classical.arbitrary N) p))⟧

tactic: apply Quotient.sound
state_before: N : Type u_1
X : Type u_2
inst✝² : TopologicalSpace X
x : X
inst✝¹ : DecidableEq N
inst✝ : Nonempty N
i : N
p : ↑(Ω^ N X x)
⊢ (⟦p⟧)⁻¹ = ⟦fromLoop (Classical.arbitrary N) (Path.symm (toLoop (Classical.arbitrary N) p))⟧
state_after: case a
N : Type u_1
X : Type u_2
inst✝² : TopologicalSpace X
x : X
inst✝¹ : DecidableEq N
inst✝ : Nonempty N
i : N
p : ↑(Ω^ N X x)
⊢ (loopHomeo (Classical.arbitrary N)).symm (Path.symm ((loopHomeo (Classical.arbitrary N)).toEquiv p)) ≈
    fromLoop (Classical.arbitrary N) (Path.symm (toLoop (Classical.arbitrary N) p))

tactic: rfl
state_before: case a
N : Type u_1
X : Type u_2
inst✝² : TopologicalSpace X
x : X
inst✝¹ : DecidableEq N
inst✝ : Nonempty N
i : N
p : ↑(Ω^ N X x)
⊢ (loopHomeo (Classical.arbitrary N)).symm (Path.symm ((loopHomeo (Classical.arbitrary N)).toEquiv p)) ≈
    fromLoop (Classical.arbitrary N) (Path.symm (toLoop (Classical.arbitrary N) p))
state_after: no goals