1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: IsNilpotent.neg
File: Mathlib/RingTheory/Nilpotent/Basic.lean

tactic: obtain ⟨n, hn⟩ := h
state_before: R : Type u_1
S : Type u_2
x y : R
inst✝ : Ring R
h : IsNilpotent x
⊢ IsNilpotent (-x)
state_after: case intro
R : Type u_1
S : Type u_2
x y : R
inst✝ : Ring R
n : ℕ
hn : x ^ n = 0
⊢ IsNilpotent (-x)

tactic: use n
state_before: case intro
R : Type u_1
S : Type u_2
x y : R
inst✝ : Ring R
n : ℕ
hn : x ^ n = 0
⊢ IsNilpotent (-x)
state_after: case h
R : Type u_1
S : Type u_2
x y : R
inst✝ : Ring R
n : ℕ
hn : x ^ n = 0
⊢ (-x) ^ n = 0

tactic: rw [neg_pow, hn, mul_zero]
state_before: case h
R : Type u_1
S : Type u_2
x y : R
inst✝ : Ring R
n : ℕ
hn : x ^ n = 0
⊢ (-x) ^ n = 0
state_after: no goals
Theorem: MeasureTheory.setIntegral_congr_set_ae
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

tactic: rw [Measure.restrict_congr_set hst]
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace X
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
hst : s =ᶠ[ae μ] t
⊢ ∫ (x : X) in s, f x ∂μ = ∫ (x : X) in t, f x ∂μ
state_after: no goals
Theorem: Complex.tan_ne_zero_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean

tactic: rw [← not_exists, not_iff_not, tan_eq_zero_iff]
state_before: θ : ℂ
⊢ tan θ ≠ 0 ↔ ∀ (k : ℤ), ↑k * ↑π / 2 ≠ θ
state_after: no goals
Theorem: CategoryTheory.Limits.equalizerSubobject_arrow_comp
File: Mathlib/CategoryTheory/Subobject/Limits.lean

tactic: rw [← equalizerSubobject_arrow, Category.assoc, Category.assoc, equalizer.condition]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : C
f g : X ⟶ Y
inst✝ : HasEqualizer f g
⊢ (equalizerSubobject f g).arrow ≫ f = (equalizerSubobject f g).arrow ≫ g
state_after: no goals
Theorem: Basis.card_le_card_of_linearIndependent_aux
File: Mathlib/LinearAlgebra/Dimension/StrongRankCondition.lean

tactic: simpa using linearIndependent_le_basis (Pi.basisFun R (Fin n)) v h
state_before: R✝ : Type u
M : Type v
inst✝⁵ : Ring R✝
inst✝⁴ : AddCommGroup M
inst✝³ : Module R✝ M
ι : Type w
ι' : Type w'
inst✝² : StrongRankCondition R✝
R : Type u_1
inst✝¹ : Ring R
inst✝ : StrongRankCondition R
n m : ℕ
v : Fin m → Fin n → R
h : LinearIndependent R v
⊢ m ≤ n
state_after: no goals
Theorem: Matrix.transposeᵣ_eq
File: Mathlib/Data/Matrix/Reflection.lean

tactic: simp_rw [transposeᵣ, transposeᵣ_eq]
state_before: l m✝ n✝ : ℕ
α : Type u_1
β : Type u_2
m n : ℕ
A : Matrix (Fin m) (Fin (n + 1)) α
i : Fin (n + 1)
j : Fin m
⊢ A.transposeᵣ i j = Aᵀ i j
state_after: l m✝ n✝ : ℕ
α : Type u_1
β : Type u_2
m n : ℕ
A : Matrix (Fin m) (Fin (n + 1)) α
i : Fin (n + 1)
j : Fin m
⊢ of (vecCons (FinVec.map (fun v => v 0) A) (A.submatrix id Fin.succ)ᵀ) i j = Aᵀ i j

tactic: refine i.cases ?_ fun i => ?_
state_before: l m✝ n✝ : ℕ
α : Type u_1
β : Type u_2
m n : ℕ
A : Matrix (Fin m) (Fin (n + 1)) α
i : Fin (n + 1)
j : Fin m
⊢ of (vecCons (FinVec.map (fun v => v 0) A) (A.submatrix id Fin.succ)ᵀ) i j = Aᵀ i j
state_after: case refine_1
l m✝ n✝ : ℕ
α : Type u_1
β : Type u_2
m n : ℕ
A : Matrix (Fin m) (Fin (n + 1)) α
i : Fin (n + 1)
j : Fin m
⊢ of (vecCons (FinVec.map (fun v => v 0) A) (A.submatrix id Fin.succ)ᵀ) 0 j = Aᵀ 0 j

case refine_2
l m✝ n✝ : ℕ
α : Type u_1
β : Type u_2
m n : ℕ
A : Matrix (Fin m) (Fin (n + 1)) α
i✝ : Fin (n + 1)
j : Fin m
i : Fin n
⊢ of (vecCons (FinVec.map (fun v => v 0) A) (A.submatrix id Fin.succ)ᵀ) i.succ j = Aᵀ i.succ j

tactic: dsimp
state_before: case refine_1
l m✝ n✝ : ℕ
α : Type u_1
β : Type u_2
m n : ℕ
A : Matrix (Fin m) (Fin (n + 1)) α
i : Fin (n + 1)
j : Fin m
⊢ of (vecCons (FinVec.map (fun v => v 0) A) (A.submatrix id Fin.succ)ᵀ) 0 j = Aᵀ 0 j
state_after: case refine_1
l m✝ n✝ : ℕ
α : Type u_1
β : Type u_2
m n : ℕ
A : Matrix (Fin m) (Fin (n + 1)) α
i : Fin (n + 1)
j : Fin m
⊢ FinVec.map (fun v => v 0) A j = A j 0

tactic: rw [FinVec.map_eq, Function.comp_apply]
state_before: case refine_1
l m✝ n✝ : ℕ
α : Type u_1
β : Type u_2
m n : ℕ
A : Matrix (Fin m) (Fin (n + 1)) α
i : Fin (n + 1)
j : Fin m
⊢ FinVec.map (fun v => v 0) A j = A j 0
state_after: no goals

tactic: simp only [of_apply, Matrix.cons_val_succ]
state_before: case refine_2
l m✝ n✝ : ℕ
α : Type u_1
β : Type u_2
m n : ℕ
A : Matrix (Fin m) (Fin (n + 1)) α
i✝ : Fin (n + 1)
j : Fin m
i : Fin n
⊢ of (vecCons (FinVec.map (fun v => v 0) A) (A.submatrix id Fin.succ)ᵀ) i.succ j = Aᵀ i.succ j
state_after: case refine_2
l m✝ n✝ : ℕ
α : Type u_1
β : Type u_2
m n : ℕ
A : Matrix (Fin m) (Fin (n + 1)) α
i✝ : Fin (n + 1)
j : Fin m
i : Fin n
⊢ (A.submatrix id Fin.succ)ᵀ i j = Aᵀ i.succ j

tactic: rfl
state_before: case refine_2
l m✝ n✝ : ℕ
α : Type u_1
β : Type u_2
m n : ℕ
A : Matrix (Fin m) (Fin (n + 1)) α
i✝ : Fin (n + 1)
j : Fin m
i : Fin n
⊢ (A.submatrix id Fin.succ)ᵀ i j = Aᵀ i.succ j
state_after: no goals
Theorem: AlgebraicGeometry.StructureSheaf.to_global_factors
File: Mathlib/AlgebraicGeometry/StructureSheaf.lean

tactic: rw [← Category.assoc]
state_before: R : Type u
inst✝ : CommRing R
⊢ toOpen R ⊤ =
    CommRingCat.ofHom (algebraMap R (Localization.Away 1)) ≫ toBasicOpen R 1 ≫ (structureSheaf R).val.map (eqToHom ⋯).op
state_after: R : Type u
inst✝ : CommRing R
⊢ toOpen R ⊤ =
    (CommRingCat.ofHom (algebraMap R (Localization.Away 1)) ≫ toBasicOpen R 1) ≫
      (structureSheaf R).val.map (eqToHom ⋯).op

tactic: change toOpen R ⊤ =
  (CommRingCat.ofHom <| (toBasicOpen R 1).comp (algebraMap R (Localization.Away 1))) ≫
  (structureSheaf R).1.map (eqToHom _).op
state_before: R : Type u
inst✝ : CommRing R
⊢ toOpen R ⊤ =
    (CommRingCat.ofHom (algebraMap R (Localization.Away 1)) ≫ toBasicOpen R 1) ≫
      (structureSheaf R).val.map (eqToHom ⋯).op
state_after: R : Type u
inst✝ : CommRing R
⊢ toOpen R ⊤ =
    CommRingCat.ofHom ((toBasicOpen R 1).comp (algebraMap R (Localization.Away 1))) ≫
      (structureSheaf R).val.map (eqToHom ⋯).op

tactic: unfold CommRingCat.ofHom
state_before: R : Type u
inst✝ : CommRing R
⊢ toOpen R ⊤ =
    CommRingCat.ofHom ((toBasicOpen R 1).comp (algebraMap R (Localization.Away 1))) ≫
      (structureSheaf R).val.map (eqToHom ⋯).op
state_after: R : Type u
inst✝ : CommRing R
⊢ toOpen R ⊤ = (toBasicOpen R 1).comp (algebraMap R (Localization.Away 1)) ≫ (structureSheaf R).val.map (eqToHom ⋯).op

tactic: rw [localization_toBasicOpen R, toOpen_res]
state_before: R : Type u
inst✝ : CommRing R
⊢ toOpen R ⊤ = (toBasicOpen R 1).comp (algebraMap R (Localization.Away 1)) ≫ (structureSheaf R).val.map (eqToHom ⋯).op
state_after: no goals
Theorem: ZMod.natCast_eq_iff
File: Mathlib/Data/ZMod/Basic.lean

tactic: constructor
state_before: p n : ℕ
z : ZMod p
inst✝ : NeZero p
⊢ ↑n = z ↔ ∃ k, n = z.val + p * k
state_after: case mp
p n : ℕ
z : ZMod p
inst✝ : NeZero p
⊢ ↑n = z → ∃ k, n = z.val + p * k

case mpr
p n : ℕ
z : ZMod p
inst✝ : NeZero p
⊢ (∃ k, n = z.val + p * k) → ↑n = z

tactic: rintro rfl
state_before: case mp
p n : ℕ
z : ZMod p
inst✝ : NeZero p
⊢ ↑n = z → ∃ k, n = z.val + p * k
state_after: case mp
p n : ℕ
inst✝ : NeZero p
⊢ ∃ k, n = (↑n).val + p * k

tactic: refine ⟨n / p, ?_⟩
state_before: case mp
p n : ℕ
inst✝ : NeZero p
⊢ ∃ k, n = (↑n).val + p * k
state_after: case mp
p n : ℕ
inst✝ : NeZero p
⊢ n = (↑n).val + p * (n / p)

tactic: rw [val_natCast, Nat.mod_add_div]
state_before: case mp
p n : ℕ
inst✝ : NeZero p
⊢ n = (↑n).val + p * (n / p)
state_after: no goals

tactic: rintro ⟨k, rfl⟩
state_before: case mpr
p n : ℕ
z : ZMod p
inst✝ : NeZero p
⊢ (∃ k, n = z.val + p * k) → ↑n = z
state_after: case mpr.intro
p : ℕ
z : ZMod p
inst✝ : NeZero p
k : ℕ
⊢ ↑(z.val + p * k) = z

tactic: rw [Nat.cast_add, natCast_zmod_val, Nat.cast_mul, natCast_self, zero_mul,
  add_zero]
state_before: case mpr.intro
p : ℕ
z : ZMod p
inst✝ : NeZero p
k : ℕ
⊢ ↑(z.val + p * k) = z
state_after: no goals
Theorem: TypeVec.snd_prod_mk
File: Mathlib/Data/TypeVec.lean

tactic: funext i
state_before: n : ℕ
α α' β β' : TypeVec.{u_1} n
f : α ⟹ β
g : α' ⟹ β'
⊢ prod.snd ⊚ (f ⊗' g) = g ⊚ prod.snd
state_after: case h
n : ℕ
α α' β β' : TypeVec.{u_1} n
f : α ⟹ β
g : α' ⟹ β'
i : Fin2 n
⊢ (prod.snd ⊚ (f ⊗' g)) i = (g ⊚ prod.snd) i

tactic: induction i with
| fz => rfl
| fs _ i_ih => apply i_ih
state_before: case h
n : ℕ
α α' β β' : TypeVec.{u_1} n
f : α ⟹ β
g : α' ⟹ β'
i : Fin2 n
⊢ (prod.snd ⊚ (f ⊗' g)) i = (g ⊚ prod.snd) i
state_after: no goals

tactic: rfl
state_before: case h.fz
n n✝ : ℕ
α α' β β' : TypeVec.{u_1} (n✝ + 1)
f : α ⟹ β
g : α' ⟹ β'
⊢ (prod.snd ⊚ (f ⊗' g)) Fin2.fz = (g ⊚ prod.snd) Fin2.fz
state_after: no goals

tactic: apply i_ih
state_before: case h.fs
n n✝ : ℕ
a✝ : Fin2 n✝
i_ih : ∀ {α α' β β' : TypeVec.{u_1} n✝} (f : α ⟹ β) (g : α' ⟹ β'), (prod.snd ⊚ (f ⊗' g)) a✝ = (g ⊚ prod.snd) a✝
α α' β β' : TypeVec.{u_1} (n✝ + 1)
f : α ⟹ β
g : α' ⟹ β'
⊢ (prod.snd ⊚ (f ⊗' g)) a✝.fs = (g ⊚ prod.snd) a✝.fs
state_after: no goals
Theorem: riemannZeta_residue_one
File: Mathlib/NumberTheory/LSeries/RiemannZeta.lean

tactic: exact hurwitzZetaEven_residue_one 0
state_before: ⊢ Tendsto (fun s => (s - 1) * riemannZeta s) (𝓝[≠] 1) (𝓝 1)
state_after: no goals
Theorem: iteratedDeriv_zero
File: Mathlib/Analysis/Calculus/IteratedDeriv/Defs.lean

tactic: ext x
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n : ℕ
f : 𝕜 → F
s : Set 𝕜
x : 𝕜
⊢ iteratedDeriv 0 f = f
state_after: case h
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n : ℕ
f : 𝕜 → F
s : Set 𝕜
x✝ x : 𝕜
⊢ iteratedDeriv 0 f x = f x

tactic: simp [iteratedDeriv]
state_before: case h
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n : ℕ
f : 𝕜 → F
s : Set 𝕜
x✝ x : 𝕜
⊢ iteratedDeriv 0 f x = f x
state_after: no goals
Theorem: Nat.one_lt_pow
File: Mathlib/Data/Nat/Defs.lean

tactic: simpa using Nat.pow_lt_pow_left ha hn
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
hn : n ≠ 0
ha : 1 < a
⊢ 1 < a ^ n
state_after: no goals
Theorem: Monoid.PushoutI.NormalWord.cons_eq_smul
File: Mathlib/GroupTheory/PushoutI.lean

tactic: apply ext_smul i
state_before: ι : Type u_1
G : ι → Type u_2
H : Type u_3
K : Type u_4
inst✝⁴ : Monoid K
inst✝³ : (i : ι) → Group (G i)
inst✝² : Group H
φ : (i : ι) → H →* G i
d : Transversal φ
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → DecidableEq (G i)
i : ι
g : G i
w : NormalWord d
hmw : w.fstIdx ≠ some i
hgr : g ∉ (φ i).range
⊢ cons g w hmw hgr = (of i) g • w
state_after: ι : Type u_1
G : ι → Type u_2
H : Type u_3
K : Type u_4
inst✝⁴ : Monoid K
inst✝³ : (i : ι) → Group (G i)
inst✝² : Group H
φ : (i : ι) → H →* G i
d : Transversal φ
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → DecidableEq (G i)
i : ι
g : G i
w : NormalWord d
hmw : w.fstIdx ≠ some i
hgr : g ∉ (φ i).range
⊢ CoprodI.of ((φ i) (cons g w hmw hgr).head) • (cons g w hmw hgr).toWord =
    CoprodI.of ((φ i) ((of i) g • w).head) • ((of i) g • w).toWord

tactic: simp only [cons, ne_eq, Word.cons_eq_smul, MonoidHom.apply_ofInjective_symm,
  equiv_fst_eq_mul_inv, mul_assoc, map_mul, map_inv, mul_smul, inv_smul_smul, summand_smul_def,
  equivPair, rcons, Word.equivPair_symm, Word.rcons_eq_smul, Equiv.coe_fn_mk,
  Word.equivPair_tail_eq_inv_smul, Equiv.coe_fn_symm_mk, smul_inv_smul]
state_before: ι : Type u_1
G : ι → Type u_2
H : Type u_3
K : Type u_4
inst✝⁴ : Monoid K
inst✝³ : (i : ι) → Group (G i)
inst✝² : Group H
φ : (i : ι) → H →* G i
d : Transversal φ
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → DecidableEq (G i)
i : ι
g : G i
w : NormalWord d
hmw : w.fstIdx ≠ some i
hgr : g ∉ (φ i).range
⊢ CoprodI.of ((φ i) (cons g w hmw hgr).head) • (cons g w hmw hgr).toWord =
    CoprodI.of ((φ i) ((of i) g • w).head) • ((of i) g • w).toWord
state_after: no goals
Theorem: taylor_within_zero_eval
File: Mathlib/Analysis/Calculus/Taylor.lean

tactic: dsimp only [taylorWithinEval]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ → E
s : Set ℝ
x₀ x : ℝ
⊢ taylorWithinEval f 0 s x₀ x = f x₀
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ → E
s : Set ℝ
x₀ x : ℝ
⊢ (PolynomialModule.eval x) (taylorWithin f 0 s x₀) = f x₀

tactic: dsimp only [taylorWithin]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ → E
s : Set ℝ
x₀ x : ℝ
⊢ (PolynomialModule.eval x) (taylorWithin f 0 s x₀) = f x₀
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ → E
s : Set ℝ
x₀ x : ℝ
⊢ (PolynomialModule.eval x)
      (∑ k ∈ Finset.range (0 + 1),
        (PolynomialModule.comp (Polynomial.X - Polynomial.C x₀))
          ((PolynomialModule.single ℝ k) (taylorCoeffWithin f k s x₀))) =
    f x₀

tactic: dsimp only [taylorCoeffWithin]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ → E
s : Set ℝ
x₀ x : ℝ
⊢ (PolynomialModule.eval x)
      (∑ k ∈ Finset.range (0 + 1),
        (PolynomialModule.comp (Polynomial.X - Polynomial.C x₀))
          ((PolynomialModule.single ℝ k) (taylorCoeffWithin f k s x₀))) =
    f x₀
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ → E
s : Set ℝ
x₀ x : ℝ
⊢ (PolynomialModule.eval x)
      (∑ k ∈ Finset.range (0 + 1),
        (PolynomialModule.comp (Polynomial.X - Polynomial.C x₀))
          ((PolynomialModule.single ℝ k) ((↑k !)⁻¹ • iteratedDerivWithin k f s x₀))) =
    f x₀

tactic: simp
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ → E
s : Set ℝ
x₀ x : ℝ
⊢ (PolynomialModule.eval x)
      (∑ k ∈ Finset.range (0 + 1),
        (PolynomialModule.comp (Polynomial.X - Polynomial.C x₀))
          ((PolynomialModule.single ℝ k) ((↑k !)⁻¹ • iteratedDerivWithin k f s x₀))) =
    f x₀
state_after: no goals
Theorem: USize.toNat_lt
File: .lake/packages/batteries/Batteries/Data/UInt.lean

tactic: rw [←USize.size_eq]
state_before: x : USize
⊢ x.toNat < 2 ^ System.Platform.numBits
state_after: x : USize
⊢ x.toNat < size

tactic: exact x.val.isLt
state_before: x : USize
⊢ x.toNat < size
state_after: no goals
Theorem: CategoryTheory.IsHomLift.of_fac
File: Mathlib/CategoryTheory/FiberedCategory/HomLift.lean

tactic: subst ha hb h
state_before: 𝒮 : Type u₁
𝒳 : Type u₂
inst✝¹ : Category.{v₁, u₂} 𝒳
inst✝ : Category.{v₂, u₁} 𝒮
p : 𝒳 ⥤ 𝒮
R S : 𝒮
a b : 𝒳
f : R ⟶ S
φ : a ⟶ b
ha : p.obj a = R
hb : p.obj b = S
h : f = eqToHom ⋯ ≫ p.map φ ≫ eqToHom hb
⊢ p.IsHomLift f φ
state_after: 𝒮 : Type u₁
𝒳 : Type u₂
inst✝¹ : Category.{v₁, u₂} 𝒳
inst✝ : Category.{v₂, u₁} 𝒮
p : 𝒳 ⥤ 𝒮
a b : 𝒳
φ : a ⟶ b
⊢ p.IsHomLift (eqToHom ⋯ ≫ p.map φ ≫ eqToHom ⋯) φ

tactic: simp
state_before: 𝒮 : Type u₁
𝒳 : Type u₂
inst✝¹ : Category.{v₁, u₂} 𝒳
inst✝ : Category.{v₂, u₁} 𝒮
p : 𝒳 ⥤ 𝒮
a b : 𝒳
φ : a ⟶ b
⊢ p.IsHomLift (eqToHom ⋯ ≫ p.map φ ≫ eqToHom ⋯) φ
state_after: no goals
Theorem: ne_one_of_map
File: Mathlib/Algebra/Group/Hom/Defs.lean

tactic: rwa [(map_one f)]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
H : Type u_8
F✝ : Type u_9
inst✝⁶ : One M
inst✝⁵ : One N
inst✝⁴ : FunLike F✝ M N
R : Type u_10
S : Type u_11
F : Type u_12
inst✝³ : One R
inst✝² : One S
inst✝¹ : FunLike F R S
inst✝ : OneHomClass F R S
f : F
x : R
hx : f x ≠ 1
⊢ f x ≠ f 1
state_after: no goals
Theorem: imaginaryPart_comp_subtype_selfAdjoint
File: Mathlib/Data/Complex/Module.lean

tactic: rw [imaginaryPart, LinearMap.comp_assoc, skewAdjointPart_comp_subtype_selfAdjoint,
  LinearMap.comp_zero]
state_before: A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
⊢ ℑ ∘ₗ (selfAdjoint.submodule ℝ A).subtype = 0
state_after: no goals
Theorem: QuasiErgodic.ae_eq_const_of_ae_eq_comp_ae
File: Mathlib/Dynamics/Ergodic/Function.lean

tactic: borelize X
state_before: α : Type u_1
X : Type u_2
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : TopologicalSpace X
inst✝¹ : MetrizableSpace X
inst✝ : Nonempty X
f : α → α
g : α → X
h : QuasiErgodic f μ
hgm : AEStronglyMeasurable g μ
hg_eq : g ∘ f =ᶠ[ae μ] g
⊢ ∃ c, g =ᶠ[ae μ] const α c
state_after: α : Type u_1
X : Type u_2
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : TopologicalSpace X
inst✝¹ : MetrizableSpace X
inst✝ : Nonempty X
f : α → α
g : α → X
h : QuasiErgodic f μ
hgm : AEStronglyMeasurable g μ
hg_eq : g ∘ f =ᶠ[ae μ] g
this✝¹ : MeasurableSpace X := borel X
this✝ : BorelSpace X
⊢ ∃ c, g =ᶠ[ae μ] const α c

tactic: rcases hgm.isSeparable_ae_range with ⟨t, ht, hgt⟩
state_before: α : Type u_1
X : Type u_2
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : TopologicalSpace X
inst✝¹ : MetrizableSpace X
inst✝ : Nonempty X
f : α → α
g : α → X
h : QuasiErgodic f μ
hgm : AEStronglyMeasurable g μ
hg_eq : g ∘ f =ᶠ[ae μ] g
this✝¹ : MeasurableSpace X := borel X
this✝ : BorelSpace X
⊢ ∃ c, g =ᶠ[ae μ] const α c
state_after: case intro.intro
α : Type u_1
X : Type u_2
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : TopologicalSpace X
inst✝¹ : MetrizableSpace X
inst✝ : Nonempty X
f : α → α
g : α → X
h : QuasiErgodic f μ
hgm : AEStronglyMeasurable g μ
hg_eq : g ∘ f =ᶠ[ae μ] g
this✝¹ : MeasurableSpace X := borel X
this✝ : BorelSpace X
t : Set X
ht : IsSeparable t
hgt : ∀ᵐ (x : α) ∂μ, g x ∈ t
⊢ ∃ c, g =ᶠ[ae μ] const α c

tactic: haveI := ht.secondCountableTopology
state_before: case intro.intro
α : Type u_1
X : Type u_2
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : TopologicalSpace X
inst✝¹ : MetrizableSpace X
inst✝ : Nonempty X
f : α → α
g : α → X
h : QuasiErgodic f μ
hgm : AEStronglyMeasurable g μ
hg_eq : g ∘ f =ᶠ[ae μ] g
this✝¹ : MeasurableSpace X := borel X
this✝ : BorelSpace X
t : Set X
ht : IsSeparable t
hgt : ∀ᵐ (x : α) ∂μ, g x ∈ t
⊢ ∃ c, g =ᶠ[ae μ] const α c
state_after: case intro.intro
α : Type u_1
X : Type u_2
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : TopologicalSpace X
inst✝¹ : MetrizableSpace X
inst✝ : Nonempty X
f : α → α
g : α → X
h : QuasiErgodic f μ
hgm : AEStronglyMeasurable g μ
hg_eq : g ∘ f =ᶠ[ae μ] g
this✝¹ : MeasurableSpace X := borel X
this✝ : BorelSpace X
t : Set X
ht : IsSeparable t
hgt : ∀ᵐ (x : α) ∂μ, g x ∈ t
this : SecondCountableTopology ↑t
⊢ ∃ c, g =ᶠ[ae μ] const α c

tactic: exact h.ae_eq_const_of_ae_eq_comp_of_ae_range₀ hgt hgm.aemeasurable.nullMeasurable hg_eq
state_before: case intro.intro
α : Type u_1
X : Type u_2
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : TopologicalSpace X
inst✝¹ : MetrizableSpace X
inst✝ : Nonempty X
f : α → α
g : α → X
h : QuasiErgodic f μ
hgm : AEStronglyMeasurable g μ
hg_eq : g ∘ f =ᶠ[ae μ] g
this✝¹ : MeasurableSpace X := borel X
this✝ : BorelSpace X
t : Set X
ht : IsSeparable t
hgt : ∀ᵐ (x : α) ∂μ, g x ∈ t
this : SecondCountableTopology ↑t
⊢ ∃ c, g =ᶠ[ae μ] const α c
state_after: no goals
Theorem: Set.Finite.pi'
File: Mathlib/Data/Set/Finite.lean

tactic: simpa [Set.pi] using Finite.pi ht
state_before: α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
inst✝ : Finite ι
κ : ι → Type u_2
t : (i : ι) → Set (κ i)
ht : ∀ (i : ι), (t i).Finite
⊢ {f | ∀ (i : ι), f i ∈ t i}.Finite
state_after: no goals
Theorem: Nat.bodd_mul
File: Mathlib/Data/Nat/Bits.lean

tactic: induction' n with n IH
state_before: m✝ n✝ m n : ℕ
⊢ (m * n).bodd = (m.bodd && n.bodd)
state_after: case zero
m✝ n m : ℕ
⊢ (m * 0).bodd = (m.bodd && bodd 0)

case succ
m✝ n✝ m n : ℕ
IH : (m * n).bodd = (m.bodd && n.bodd)
⊢ (m * (n + 1)).bodd = (m.bodd && (n + 1).bodd)

tactic: simp
state_before: case zero
m✝ n m : ℕ
⊢ (m * 0).bodd = (m.bodd && bodd 0)
state_after: no goals

tactic: simp only [mul_succ, bodd_add, IH, bodd_succ]
state_before: case succ
m✝ n✝ m n : ℕ
IH : (m * n).bodd = (m.bodd && n.bodd)
⊢ (m * (n + 1)).bodd = (m.bodd && (n + 1).bodd)
state_after: case succ
m✝ n✝ m n : ℕ
IH : (m * n).bodd = (m.bodd && n.bodd)
⊢ bxor (m.bodd && n.bodd) m.bodd = (m.bodd && !n.bodd)

tactic: cases bodd m <;> cases bodd n <;> rfl
state_before: case succ
m✝ n✝ m n : ℕ
IH : (m * n).bodd = (m.bodd && n.bodd)
⊢ bxor (m.bodd && n.bodd) m.bodd = (m.bodd && !n.bodd)
state_after: no goals
Theorem: CategoryTheory.Equalizer.FirstObj.ext
File: Mathlib/CategoryTheory/Sites/EqualizerSheafCondition.lean

tactic: apply Limits.Types.limit_ext
state_before: C : Type u
inst✝ : Category.{v, u} C
P : Cᵒᵖ ⥤ Type (max v u)
X : C
R : Presieve X
S : Sieve X
z₁ z₂ : FirstObj P R
h :
  ∀ (Y : C) (f : Y ⟶ X) (hf : R f),
    Pi.π (fun f => P.obj { unop := f.fst }) ⟨Y, ⟨f, hf⟩⟩ z₁ = Pi.π (fun f => P.obj { unop := f.fst }) ⟨Y, ⟨f, hf⟩⟩ z₂
⊢ z₁ = z₂
state_after: case w
C : Type u
inst✝ : Category.{v, u} C
P : Cᵒᵖ ⥤ Type (max v u)
X : C
R : Presieve X
S : Sieve X
z₁ z₂ : FirstObj P R
h :
  ∀ (Y : C) (f : Y ⟶ X) (hf : R f),
    Pi.π (fun f => P.obj { unop := f.fst }) ⟨Y, ⟨f, hf⟩⟩ z₁ = Pi.π (fun f => P.obj { unop := f.fst }) ⟨Y, ⟨f, hf⟩⟩ z₂
⊢ ∀ (j : Discrete ((Y : C) × { f // R f })),
    limit.π (Discrete.functor fun f => P.obj { unop := f.fst }) j z₁ =
      limit.π (Discrete.functor fun f => P.obj { unop := f.fst }) j z₂

tactic: rintro ⟨⟨Y, f, hf⟩⟩
state_before: case w
C : Type u
inst✝ : Category.{v, u} C
P : Cᵒᵖ ⥤ Type (max v u)
X : C
R : Presieve X
S : Sieve X
z₁ z₂ : FirstObj P R
h :
  ∀ (Y : C) (f : Y ⟶ X) (hf : R f),
    Pi.π (fun f => P.obj { unop := f.fst }) ⟨Y, ⟨f, hf⟩⟩ z₁ = Pi.π (fun f => P.obj { unop := f.fst }) ⟨Y, ⟨f, hf⟩⟩ z₂
⊢ ∀ (j : Discrete ((Y : C) × { f // R f })),
    limit.π (Discrete.functor fun f => P.obj { unop := f.fst }) j z₁ =
      limit.π (Discrete.functor fun f => P.obj { unop := f.fst }) j z₂
state_after: case w.mk.mk.mk
C : Type u
inst✝ : Category.{v, u} C
P : Cᵒᵖ ⥤ Type (max v u)
X : C
R : Presieve X
S : Sieve X
z₁ z₂ : FirstObj P R
h :
  ∀ (Y : C) (f : Y ⟶ X) (hf : R f),
    Pi.π (fun f => P.obj { unop := f.fst }) ⟨Y, ⟨f, hf⟩⟩ z₁ = Pi.π (fun f => P.obj { unop := f.fst }) ⟨Y, ⟨f, hf⟩⟩ z₂
Y : C
f : Y ⟶ X
hf : R f
⊢ limit.π (Discrete.functor fun f => P.obj { unop := f.fst }) { as := ⟨Y, ⟨f, hf⟩⟩ } z₁ =
    limit.π (Discrete.functor fun f => P.obj { unop := f.fst }) { as := ⟨Y, ⟨f, hf⟩⟩ } z₂

tactic: exact h Y f hf
state_before: case w.mk.mk.mk
C : Type u
inst✝ : Category.{v, u} C
P : Cᵒᵖ ⥤ Type (max v u)
X : C
R : Presieve X
S : Sieve X
z₁ z₂ : FirstObj P R
h :
  ∀ (Y : C) (f : Y ⟶ X) (hf : R f),
    Pi.π (fun f => P.obj { unop := f.fst }) ⟨Y, ⟨f, hf⟩⟩ z₁ = Pi.π (fun f => P.obj { unop := f.fst }) ⟨Y, ⟨f, hf⟩⟩ z₂
Y : C
f : Y ⟶ X
hf : R f
⊢ limit.π (Discrete.functor fun f => P.obj { unop := f.fst }) { as := ⟨Y, ⟨f, hf⟩⟩ } z₁ =
    limit.π (Discrete.functor fun f => P.obj { unop := f.fst }) { as := ⟨Y, ⟨f, hf⟩⟩ } z₂
state_after: no goals
Theorem: Finset.erase_subset_iff_of_mem
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [← subset_insert_iff, insert_eq_of_mem h]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
h : a ∈ t
⊢ s.erase a ⊆ t ↔ s ⊆ t
state_after: no goals
Theorem: Finite.exists_ne_map_eq_of_infinite
File: Mathlib/Data/Fintype/Card.lean

tactic: simpa [Injective, and_comm] using not_injective_infinite_finite f
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
α : Sort u_4
β : Sort u_5
inst✝¹ : Infinite α
inst✝ : Finite β
f : α → β
⊢ ∃ x y, x ≠ y ∧ f x = f y
state_after: no goals
Theorem: supIrred_iff_not_isMin
File: Mathlib/Order/Irreducible.lean

tactic: simpa only [sup_eq_max, max_eq_iff] using Or.imp And.left And.left
state_before: ι : Type u_1
α : Type u_2
inst✝ : LinearOrder α
a x✝¹ x✝ : α
⊢ x✝¹ ⊔ x✝ = a → x✝¹ = a ∨ x✝ = a
state_after: no goals