1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Filter.tendsto_cocompact_mul_right
File: Mathlib/Topology/Algebra/Monoid.lean

tactic: refine Filter.Tendsto.of_tendsto_comp ?_ (Filter.comap_cocompact_le (continuous_mul_right b))
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
a b : M
ha : a * b = 1
⊢ Tendsto (fun x => x * a) (cocompact M) (cocompact M)
state_after: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
a b : M
ha : a * b = 1
⊢ Tendsto ((fun b_1 => b_1 * b) ∘ fun x => x * a) (cocompact M) (cocompact M)

tactic: simp only [comp_mul_right, ha, mul_one]
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
a b : M
ha : a * b = 1
⊢ Tendsto ((fun b_1 => b_1 * b) ∘ fun x => x * a) (cocompact M) (cocompact M)
state_after: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
a b : M
ha : a * b = 1
⊢ Tendsto (fun x => x) (cocompact M) (cocompact M)

tactic: exact Filter.tendsto_id
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
a b : M
ha : a * b = 1
⊢ Tendsto (fun x => x) (cocompact M) (cocompact M)
state_after: no goals
Theorem: MeasureTheory.restrict_compl_sigmaFiniteSet_eq_zero_or_top
File: Mathlib/MeasureTheory/Measure/WithDensityFinite.lean

tactic: rw [restrict_compl_sigmaFiniteSet]
state_before: α : Type u_1
mα : MeasurableSpace α
μ✝ : Measure α
s✝ t : Set α
μ : Measure α
inst✝ : SFinite μ
s : Set α
⊢ (μ.restrict μ.sigmaFiniteSetᶜ) s = 0 ∨ (μ.restrict μ.sigmaFiniteSetᶜ) s = ⊤
state_after: α : Type u_1
mα : MeasurableSpace α
μ✝ : Measure α
s✝ t : Set α
μ : Measure α
inst✝ : SFinite μ
s : Set α
⊢ (⊤ • μ.toFinite.restrict μ.sigmaFiniteSetᶜ) s = 0 ∨ (⊤ • μ.toFinite.restrict μ.sigmaFiniteSetᶜ) s = ⊤

tactic: simp only [Measure.coe_smul, Pi.smul_apply, smul_eq_mul, mul_eq_zero, ENNReal.top_ne_zero,
  false_or]
state_before: α : Type u_1
mα : MeasurableSpace α
μ✝ : Measure α
s✝ t : Set α
μ : Measure α
inst✝ : SFinite μ
s : Set α
⊢ (⊤ • μ.toFinite.restrict μ.sigmaFiniteSetᶜ) s = 0 ∨ (⊤ • μ.toFinite.restrict μ.sigmaFiniteSetᶜ) s = ⊤
state_after: α : Type u_1
mα : MeasurableSpace α
μ✝ : Measure α
s✝ t : Set α
μ : Measure α
inst✝ : SFinite μ
s : Set α
⊢ (μ.toFinite.restrict μ.sigmaFiniteSetᶜ) s = 0 ∨ ⊤ * (μ.toFinite.restrict μ.sigmaFiniteSetᶜ) s = ⊤

tactic: rw [Measure.restrict_apply' (measurableSet_sigmaFiniteSet μ).compl]
state_before: α : Type u_1
mα : MeasurableSpace α
μ✝ : Measure α
s✝ t : Set α
μ : Measure α
inst✝ : SFinite μ
s : Set α
⊢ (μ.toFinite.restrict μ.sigmaFiniteSetᶜ) s = 0 ∨ ⊤ * (μ.toFinite.restrict μ.sigmaFiniteSetᶜ) s = ⊤
state_after: α : Type u_1
mα : MeasurableSpace α
μ✝ : Measure α
s✝ t : Set α
μ : Measure α
inst✝ : SFinite μ
s : Set α
⊢ μ.toFinite (s ∩ μ.sigmaFiniteSetᶜ) = 0 ∨ ⊤ * μ.toFinite (s ∩ μ.sigmaFiniteSetᶜ) = ⊤

tactic: by_cases h_zero : μ.toFinite (s ∩ μ.sigmaFiniteSetᶜ) = 0
state_before: α : Type u_1
mα : MeasurableSpace α
μ✝ : Measure α
s✝ t : Set α
μ : Measure α
inst✝ : SFinite μ
s : Set α
⊢ μ.toFinite (s ∩ μ.sigmaFiniteSetᶜ) = 0 ∨ ⊤ * μ.toFinite (s ∩ μ.sigmaFiniteSetᶜ) = ⊤
state_after: case pos
α : Type u_1
mα : MeasurableSpace α
μ✝ : Measure α
s✝ t : Set α
μ : Measure α
inst✝ : SFinite μ
s : Set α
h_zero : μ.toFinite (s ∩ μ.sigmaFiniteSetᶜ) = 0
⊢ μ.toFinite (s ∩ μ.sigmaFiniteSetᶜ) = 0 ∨ ⊤ * μ.toFinite (s ∩ μ.sigmaFiniteSetᶜ) = ⊤

case neg
α : Type u_1
mα : MeasurableSpace α
μ✝ : Measure α
s✝ t : Set α
μ : Measure α
inst✝ : SFinite μ
s : Set α
h_zero : ¬μ.toFinite (s ∩ μ.sigmaFiniteSetᶜ) = 0
⊢ μ.toFinite (s ∩ μ.sigmaFiniteSetᶜ) = 0 ∨ ⊤ * μ.toFinite (s ∩ μ.sigmaFiniteSetᶜ) = ⊤

tactic: exact Or.inl h_zero
state_before: case pos
α : Type u_1
mα : MeasurableSpace α
μ✝ : Measure α
s✝ t : Set α
μ : Measure α
inst✝ : SFinite μ
s : Set α
h_zero : μ.toFinite (s ∩ μ.sigmaFiniteSetᶜ) = 0
⊢ μ.toFinite (s ∩ μ.sigmaFiniteSetᶜ) = 0 ∨ ⊤ * μ.toFinite (s ∩ μ.sigmaFiniteSetᶜ) = ⊤
state_after: no goals

tactic: exact Or.inr (ENNReal.top_mul h_zero)
state_before: case neg
α : Type u_1
mα : MeasurableSpace α
μ✝ : Measure α
s✝ t : Set α
μ : Measure α
inst✝ : SFinite μ
s : Set α
h_zero : ¬μ.toFinite (s ∩ μ.sigmaFiniteSetᶜ) = 0
⊢ μ.toFinite (s ∩ μ.sigmaFiniteSetᶜ) = 0 ∨ ⊤ * μ.toFinite (s ∩ μ.sigmaFiniteSetᶜ) = ⊤
state_after: no goals
Theorem: IsPrimitiveRoot.integralPowerBasis_dim
File: Mathlib/NumberTheory/Cyclotomic/Rat.lean

tactic: simp [integralPowerBasis, ← cyclotomic_eq_minpoly hζ, natDegree_cyclotomic]
state_before: p : ℕ+
k : ℕ
K : Type u
inst✝¹ : Field K
inst✝ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
hcycl : IsCyclotomicExtension {p ^ k} ℚ K
hζ : IsPrimitiveRoot ζ ↑(p ^ k)
⊢ hζ.integralPowerBasis.dim = φ (↑p ^ k)
state_after: no goals
Theorem: MeasureTheory.integrable_rnDeriv_smul_iff
File: Mathlib/MeasureTheory/Decomposition/RadonNikodym.lean

tactic: nth_rw 2 [← withDensity_rnDeriv_eq μ ν hμν]
state_before: α✝ : Type u_1
β : Type u_2
m✝ : MeasurableSpace α✝
α : Type u_3
m : MeasurableSpace α
μ ν : Measure α
E : Type u_4
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : CompleteSpace E
inst✝¹ : μ.HaveLebesgueDecomposition ν
hμν : μ ≪ ν
inst✝ : SigmaFinite μ
f : α → E
⊢ Integrable (fun x => (μ.rnDeriv ν x).toReal • f x) ν ↔ Integrable f μ
state_after: α✝ : Type u_1
β : Type u_2
m✝ : MeasurableSpace α✝
α : Type u_3
m : MeasurableSpace α
μ ν : Measure α
E : Type u_4
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : CompleteSpace E
inst✝¹ : μ.HaveLebesgueDecomposition ν
hμν : μ ≪ ν
inst✝ : SigmaFinite μ
f : α → E
⊢ Integrable (fun x => (μ.rnDeriv ν x).toReal • f x) ν ↔ Integrable f (ν.withDensity (μ.rnDeriv ν))

tactic: rw [← integrable_withDensity_iff_integrable_smul' (E := E)
  (measurable_rnDeriv μ ν) (rnDeriv_lt_top μ ν)]
state_before: α✝ : Type u_1
β : Type u_2
m✝ : MeasurableSpace α✝
α : Type u_3
m : MeasurableSpace α
μ ν : Measure α
E : Type u_4
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : CompleteSpace E
inst✝¹ : μ.HaveLebesgueDecomposition ν
hμν : μ ≪ ν
inst✝ : SigmaFinite μ
f : α → E
⊢ Integrable (fun x => (μ.rnDeriv ν x).toReal • f x) ν ↔ Integrable f (ν.withDensity (μ.rnDeriv ν))
state_after: no goals
Theorem: IsOfFinOrder.mem_powers_iff_mem_zpowers
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: simp_all
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Group G
x y : G
i : ℤ
hx : IsOfFinOrder x
x✝ : y ∈ powers x
n : ℕ
hn : (fun x_1 => x ^ x_1) n = y
⊢ (fun x_1 => x ^ x_1) ↑n = y
state_after: no goals

tactic: dsimp only
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Group G
x y : G
i✝ : ℤ
hx : IsOfFinOrder x
x✝ : y ∈ zpowers x
i : ℤ
hi : (fun x_1 => x ^ x_1) i = y
⊢ (fun x_1 => x ^ x_1) (i % ↑(orderOf x)).natAbs = y
state_after: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Group G
x y : G
i✝ : ℤ
hx : IsOfFinOrder x
x✝ : y ∈ zpowers x
i : ℤ
hi : (fun x_1 => x ^ x_1) i = y
⊢ x ^ (i % ↑(orderOf x)).natAbs = y

tactic: rwa [← zpow_natCast, Int.natAbs_of_nonneg <| Int.emod_nonneg _ <|
  Int.natCast_ne_zero_iff_pos.2 <| hx.orderOf_pos, zpow_mod_orderOf]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Group G
x y : G
i✝ : ℤ
hx : IsOfFinOrder x
x✝ : y ∈ zpowers x
i : ℤ
hi : (fun x_1 => x ^ x_1) i = y
⊢ x ^ (i % ↑(orderOf x)).natAbs = y
state_after: no goals
Theorem: NormedSpace.dualPairing_separatingLeft
File: Mathlib/Analysis/NormedSpace/Dual.lean

tactic: rw [LinearMap.separatingLeft_iff_ker_eq_bot, LinearMap.ker_eq_bot]
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
⊢ (dualPairing 𝕜 E).SeparatingLeft
state_after: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
⊢ Function.Injective ⇑(dualPairing 𝕜 E)

tactic: exact ContinuousLinearMap.coe_injective
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
⊢ Function.Injective ⇑(dualPairing 𝕜 E)
state_after: no goals
Theorem: Matrix.det_eq_zero_of_column_eq_zero
File: Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean

tactic: rw [← det_transpose]
state_before: m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
j : n
h : ∀ (i : n), A i j = 0
⊢ A.det = 0
state_after: m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
j : n
h : ∀ (i : n), A i j = 0
⊢ Aᵀ.det = 0

tactic: exact det_eq_zero_of_row_eq_zero j h
state_before: m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
j : n
h : ∀ (i : n), A i j = 0
⊢ Aᵀ.det = 0
state_after: no goals
Theorem: IsCyclotomicExtension.singleton_zero_of_bot_eq_top
File: Mathlib/NumberTheory/Cyclotomic/Basic.lean

tactic: refine (iff_adjoin_eq_top _ A _).2
  ⟨fun s hs => by simp at hs, _root_.eq_top_iff.2 fun x hx => ?_⟩
state_before: n : ℕ+
S T : Set ℕ+
A : Type u
B : Type v
K : Type w
L : Type z
inst✝⁵ : CommRing A
inst✝⁴ : CommRing B
inst✝³ : Algebra A B
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Algebra K L
h : ⊥ = ⊤
⊢ IsCyclotomicExtension ∅ A B
state_after: n : ℕ+
S T : Set ℕ+
A : Type u
B : Type v
K : Type w
L : Type z
inst✝⁵ : CommRing A
inst✝⁴ : CommRing B
inst✝³ : Algebra A B
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Algebra K L
h : ⊥ = ⊤
x : B
hx : x ∈ ⊤
⊢ x ∈ adjoin A {b | ∃ n ∈ ∅, b ^ ↑n = 1}

tactic: rw [← h] at hx
state_before: n : ℕ+
S T : Set ℕ+
A : Type u
B : Type v
K : Type w
L : Type z
inst✝⁵ : CommRing A
inst✝⁴ : CommRing B
inst✝³ : Algebra A B
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Algebra K L
h : ⊥ = ⊤
x : B
hx : x ∈ ⊤
⊢ x ∈ adjoin A {b | ∃ n ∈ ∅, b ^ ↑n = 1}
state_after: n : ℕ+
S T : Set ℕ+
A : Type u
B : Type v
K : Type w
L : Type z
inst✝⁵ : CommRing A
inst✝⁴ : CommRing B
inst✝³ : Algebra A B
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Algebra K L
h : ⊥ = ⊤
x : B
hx : x ∈ ⊥
⊢ x ∈ adjoin A {b | ∃ n ∈ ∅, b ^ ↑n = 1}

tactic: simpa using hx
state_before: n : ℕ+
S T : Set ℕ+
A : Type u
B : Type v
K : Type w
L : Type z
inst✝⁵ : CommRing A
inst✝⁴ : CommRing B
inst✝³ : Algebra A B
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Algebra K L
h : ⊥ = ⊤
x : B
hx : x ∈ ⊥
⊢ x ∈ adjoin A {b | ∃ n ∈ ∅, b ^ ↑n = 1}
state_after: no goals

tactic: simp at hs
state_before: n : ℕ+
S T : Set ℕ+
A : Type u
B : Type v
K : Type w
L : Type z
inst✝⁵ : CommRing A
inst✝⁴ : CommRing B
inst✝³ : Algebra A B
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Algebra K L
h : ⊥ = ⊤
s : ℕ+
hs : s ∈ ∅
⊢ ∃ r, IsPrimitiveRoot r ↑s
state_after: no goals
Theorem: TruncatedWittVector.commutes_symm'
File: Mathlib/RingTheory/WittVector/Compare.lean

tactic: apply (zmodEquivTrunc p n).injective
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝ : CommRing R
m : ℕ
hm : n ≤ m
x : TruncatedWittVector p m (ZMod p)
⊢ (zmodEquivTrunc p n).symm ((truncate hm) x) = (ZMod.castHom ⋯ (ZMod (p ^ n))) ((zmodEquivTrunc p m).symm x)
state_after: case a
p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝ : CommRing R
m : ℕ
hm : n ≤ m
x : TruncatedWittVector p m (ZMod p)
⊢ (zmodEquivTrunc p n) ((zmodEquivTrunc p n).symm ((truncate hm) x)) =
    (zmodEquivTrunc p n) ((ZMod.castHom ⋯ (ZMod (p ^ n))) ((zmodEquivTrunc p m).symm x))

tactic: rw [← commutes' _ _ hm]
state_before: case a
p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝ : CommRing R
m : ℕ
hm : n ≤ m
x : TruncatedWittVector p m (ZMod p)
⊢ (zmodEquivTrunc p n) ((zmodEquivTrunc p n).symm ((truncate hm) x)) =
    (zmodEquivTrunc p n) ((ZMod.castHom ⋯ (ZMod (p ^ n))) ((zmodEquivTrunc p m).symm x))
state_after: case a
p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝ : CommRing R
m : ℕ
hm : n ≤ m
x : TruncatedWittVector p m (ZMod p)
⊢ (zmodEquivTrunc p n) ((zmodEquivTrunc p n).symm ((truncate hm) x)) =
    (truncate hm) ((zmodEquivTrunc p m) ((zmodEquivTrunc p m).symm x))

tactic: simp
state_before: case a
p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝ : CommRing R
m : ℕ
hm : n ≤ m
x : TruncatedWittVector p m (ZMod p)
⊢ (zmodEquivTrunc p n) ((zmodEquivTrunc p n).symm ((truncate hm) x)) =
    (truncate hm) ((zmodEquivTrunc p m) ((zmodEquivTrunc p m).symm x))
state_after: no goals
Theorem: Profinite.NobelingProof.ord_term_aux
File: Mathlib/Topology/Category/Profinite/Nobeling.lean

tactic: simp only [ord, term, Ordinal.typein_enum]
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
ho : o < Ordinal.type fun x x_1 => x < x_1
⊢ ord I (term I ho) = o
state_after: no goals
Theorem: dNext_nat
File: Mathlib/Algebra/Homology/Homotopy.lean

tactic: dsimp [dNext]
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C✝ D✝ E : HomologicalComplex V c
f✝ g : C✝ ⟶ D✝
h k : D✝ ⟶ E
i✝ : ι
C D : ChainComplex V ℕ
i : ℕ
f : (i j : ℕ) → C.X i ⟶ D.X j
⊢ (dNext i) f = C.d i (i - 1) ≫ f (i - 1) i
state_after: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C✝ D✝ E : HomologicalComplex V c
f✝ g : C✝ ⟶ D✝
h k : D✝ ⟶ E
i✝ : ι
C D : ChainComplex V ℕ
i : ℕ
f : (i j : ℕ) → C.X i ⟶ D.X j
⊢ C.d i ((ComplexShape.down ℕ).next i) ≫ f ((ComplexShape.down ℕ).next i) i = C.d i (i - 1) ≫ f (i - 1) i

tactic: cases i
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C✝ D✝ E : HomologicalComplex V c
f✝ g : C✝ ⟶ D✝
h k : D✝ ⟶ E
i✝ : ι
C D : ChainComplex V ℕ
i : ℕ
f : (i j : ℕ) → C.X i ⟶ D.X j
⊢ C.d i ((ComplexShape.down ℕ).next i) ≫ f ((ComplexShape.down ℕ).next i) i = C.d i (i - 1) ≫ f (i - 1) i
state_after: case zero
ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C✝ D✝ E : HomologicalComplex V c
f✝ g : C✝ ⟶ D✝
h k : D✝ ⟶ E
i : ι
C D : ChainComplex V ℕ
f : (i j : ℕ) → C.X i ⟶ D.X j
⊢ C.d 0 ((ComplexShape.down ℕ).next 0) ≫ f ((ComplexShape.down ℕ).next 0) 0 = C.d 0 (0 - 1) ≫ f (0 - 1) 0

case succ
ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C✝ D✝ E : HomologicalComplex V c
f✝ g : C✝ ⟶ D✝
h k : D✝ ⟶ E
i : ι
C D : ChainComplex V ℕ
f : (i j : ℕ) → C.X i ⟶ D.X j
n✝ : ℕ
⊢ C.d (n✝ + 1) ((ComplexShape.down ℕ).next (n✝ + 1)) ≫ f ((ComplexShape.down ℕ).next (n✝ + 1)) (n✝ + 1) =
    C.d (n✝ + 1) (n✝ + 1 - 1) ≫ f (n✝ + 1 - 1) (n✝ + 1)

tactic: simp only [shape, ChainComplex.next_nat_zero, ComplexShape.down_Rel, Nat.one_ne_zero,
  not_false_iff, zero_comp]
state_before: case zero
ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C✝ D✝ E : HomologicalComplex V c
f✝ g : C✝ ⟶ D✝
h k : D✝ ⟶ E
i : ι
C D : ChainComplex V ℕ
f : (i j : ℕ) → C.X i ⟶ D.X j
⊢ C.d 0 ((ComplexShape.down ℕ).next 0) ≫ f ((ComplexShape.down ℕ).next 0) 0 = C.d 0 (0 - 1) ≫ f (0 - 1) 0
state_after: no goals

tactic: congr <;> simp
state_before: case succ
ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C✝ D✝ E : HomologicalComplex V c
f✝ g : C✝ ⟶ D✝
h k : D✝ ⟶ E
i : ι
C D : ChainComplex V ℕ
f : (i j : ℕ) → C.X i ⟶ D.X j
n✝ : ℕ
⊢ C.d (n✝ + 1) ((ComplexShape.down ℕ).next (n✝ + 1)) ≫ f ((ComplexShape.down ℕ).next (n✝ + 1)) (n✝ + 1) =
    C.d (n✝ + 1) (n✝ + 1 - 1) ≫ f (n✝ + 1 - 1) (n✝ + 1)
state_after: no goals
Theorem: Int.lt_succ_self
File: Mathlib/Data/Int/Defs.lean

tactic: unfold succ
state_before: a✝ b c d m n a : ℤ
⊢ a < a.succ
state_after: a✝ b c d m n a : ℤ
⊢ a < a + 1

tactic: omega
state_before: a✝ b c d m n a : ℤ
⊢ a < a + 1
state_after: no goals
Theorem: Real.mul_pos
File: Mathlib/Data/Real/Basic.lean

tactic: induction' a using Real.ind_mk with a
state_before: x y a b : ℝ
⊢ 0 < a → 0 < b → 0 < a * b
state_after: case h
x y b : ℝ
a : CauSeq ℚ abs
⊢ 0 < mk a → 0 < b → 0 < mk a * b

tactic: induction' b using Real.ind_mk with b
state_before: case h
x y b : ℝ
a : CauSeq ℚ abs
⊢ 0 < mk a → 0 < b → 0 < mk a * b
state_after: case h.h
x y : ℝ
a b : CauSeq ℚ abs
⊢ 0 < mk a → 0 < mk b → 0 < mk a * mk b

tactic: simpa only [mk_lt, mk_pos, ← mk_mul] using CauSeq.mul_pos
state_before: case h.h
x y : ℝ
a b : CauSeq ℚ abs
⊢ 0 < mk a → 0 < mk b → 0 < mk a * mk b
state_after: no goals
Theorem: CategoryTheory.CosimplicialObject.δ_comp_δ'
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

tactic: simp only [hj, Fin.not_lt_zero] at H
state_before: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 3)
H : i.castSucc < j
hj : j = 0
⊢ False
state_after: no goals

tactic: dsimp [δ]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 3)
H : i.castSucc < j
⊢ X.δ i ≫ X.δ j = X.δ (j.pred ⋯) ≫ X.δ i.castSucc
state_after: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 3)
H : i.castSucc < j
⊢ X.map (SimplexCategory.δ i) ≫ X.map (SimplexCategory.δ j) =
    X.map (SimplexCategory.δ (j.pred ⋯)) ≫ X.map (SimplexCategory.δ i.castSucc)

tactic: simp only [← X.map_comp, ← op_comp, SimplexCategory.δ_comp_δ' H]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 3)
H : i.castSucc < j
⊢ X.map (SimplexCategory.δ i) ≫ X.map (SimplexCategory.δ j) =
    X.map (SimplexCategory.δ (j.pred ⋯)) ≫ X.map (SimplexCategory.δ i.castSucc)
state_after: no goals
Theorem: MeasureTheory.NullMeasurableSet.exists_measurable_superset_ae_eq
File: Mathlib/MeasureTheory/Measure/NullMeasurable.lean

tactic: rcases h with ⟨t, htm, hst⟩
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s t : Set α
h : NullMeasurableSet s μ
⊢ ∃ t ⊇ s, MeasurableSet t ∧ t =ᶠ[ae μ] s
state_after: case intro.intro
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s t✝ t : Set α
htm : MeasurableSet t
hst : s =ᶠ[ae μ] t
⊢ ∃ t ⊇ s, MeasurableSet t ∧ t =ᶠ[ae μ] s

tactic: refine ⟨t ∪ toMeasurable μ (s \ t), ?_, htm.union (measurableSet_toMeasurable _ _), ?_⟩
state_before: case intro.intro
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s t✝ t : Set α
htm : MeasurableSet t
hst : s =ᶠ[ae μ] t
⊢ ∃ t ⊇ s, MeasurableSet t ∧ t =ᶠ[ae μ] s
state_after: case intro.intro.refine_1
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s t✝ t : Set α
htm : MeasurableSet t
hst : s =ᶠ[ae μ] t
⊢ t ∪ toMeasurable μ (s \ t) ⊇ s

case intro.intro.refine_2
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s t✝ t : Set α
htm : MeasurableSet t
hst : s =ᶠ[ae μ] t
⊢ t ∪ toMeasurable μ (s \ t) =ᶠ[ae μ] s

tactic: exact diff_subset_iff.1 (subset_toMeasurable _ _)
state_before: case intro.intro.refine_1
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s t✝ t : Set α
htm : MeasurableSet t
hst : s =ᶠ[ae μ] t
⊢ t ∪ toMeasurable μ (s \ t) ⊇ s
state_after: no goals

tactic: have : toMeasurable μ (s \ t) =ᵐ[μ] (∅ : Set α) := by simp [ae_le_set.1 hst.le]
state_before: case intro.intro.refine_2
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s t✝ t : Set α
htm : MeasurableSet t
hst : s =ᶠ[ae μ] t
⊢ t ∪ toMeasurable μ (s \ t) =ᶠ[ae μ] s
state_after: case intro.intro.refine_2
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s t✝ t : Set α
htm : MeasurableSet t
hst : s =ᶠ[ae μ] t
this : toMeasurable μ (s \ t) =ᶠ[ae μ] ∅
⊢ t ∪ toMeasurable μ (s \ t) =ᶠ[ae μ] s

tactic: simpa only [union_empty] using hst.symm.union this
state_before: case intro.intro.refine_2
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s t✝ t : Set α
htm : MeasurableSet t
hst : s =ᶠ[ae μ] t
this : toMeasurable μ (s \ t) =ᶠ[ae μ] ∅
⊢ t ∪ toMeasurable μ (s \ t) =ᶠ[ae μ] s
state_after: no goals

tactic: simp [ae_le_set.1 hst.le]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s t✝ t : Set α
htm : MeasurableSet t
hst : s =ᶠ[ae μ] t
⊢ toMeasurable μ (s \ t) =ᶠ[ae μ] ∅
state_after: no goals
Theorem: Finset.prod_ite_irrel
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

tactic: split_ifs with h <;> rfl
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝¹ : CommMonoid β
p : Prop
inst✝ : Decidable p
s : Finset α
f g : α → β
⊢ (∏ x ∈ s, if p then f x else g x) = if p then ∏ x ∈ s, f x else ∏ x ∈ s, g x
state_after: no goals
Theorem: CategoryTheory.Limits.limit.isoLimitCone_inv_π
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

tactic: dsimp [limit.isoLimitCone, IsLimit.conePointUniqueUpToIso]
state_before: J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u
inst✝¹ : Category.{v, u} C
F✝ F : J ⥤ C
inst✝ : HasLimit F
t : LimitCone F
j : J
⊢ (isoLimitCone t).inv ≫ π F j = t.cone.π.app j
state_after: J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u
inst✝¹ : Category.{v, u} C
F✝ F : J ⥤ C
inst✝ : HasLimit F
t : LimitCone F
j : J
⊢ lift F t.cone ≫ π F j = t.cone.π.app j

tactic: aesop_cat
state_before: J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u
inst✝¹ : Category.{v, u} C
F✝ F : J ⥤ C
inst✝ : HasLimit F
t : LimitCone F
j : J
⊢ lift F t.cone ≫ π F j = t.cone.π.app j
state_after: no goals