1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: MeasureTheory.stoppedProcess_eq''
File: Mathlib/Probability/Process/Stopping.lean

tactic: have h_mem : ∀ ω, τ ω < n → τ ω ∈ Finset.Iio n := fun ω h => Finset.mem_Iio.mpr h
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
μ : Measure Ω
τ σ : Ω → ι
E : Type u_4
p : ℝ≥0∞
u : ι → Ω → E
inst✝² : LinearOrder ι
inst✝¹ : LocallyFiniteOrderBot ι
inst✝ : AddCommMonoid E
n : ι
⊢ stoppedProcess u τ n = {a | n ≤ τ a}.indicator (u n) + ∑ i ∈ Finset.Iio n, {ω | τ ω = i}.indicator (u i)
state_after: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
μ : Measure Ω
τ σ : Ω → ι
E : Type u_4
p : ℝ≥0∞
u : ι → Ω → E
inst✝² : LinearOrder ι
inst✝¹ : LocallyFiniteOrderBot ι
inst✝ : AddCommMonoid E
n : ι
h_mem : ∀ (ω : Ω), τ ω < n → τ ω ∈ Finset.Iio n
⊢ stoppedProcess u τ n = {a | n ≤ τ a}.indicator (u n) + ∑ i ∈ Finset.Iio n, {ω | τ ω = i}.indicator (u i)

tactic: rw [stoppedProcess_eq_of_mem_finset n h_mem]
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
μ : Measure Ω
τ σ : Ω → ι
E : Type u_4
p : ℝ≥0∞
u : ι → Ω → E
inst✝² : LinearOrder ι
inst✝¹ : LocallyFiniteOrderBot ι
inst✝ : AddCommMonoid E
n : ι
h_mem : ∀ (ω : Ω), τ ω < n → τ ω ∈ Finset.Iio n
⊢ stoppedProcess u τ n = {a | n ≤ τ a}.indicator (u n) + ∑ i ∈ Finset.Iio n, {ω | τ ω = i}.indicator (u i)
state_after: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
μ : Measure Ω
τ σ : Ω → ι
E : Type u_4
p : ℝ≥0∞
u : ι → Ω → E
inst✝² : LinearOrder ι
inst✝¹ : LocallyFiniteOrderBot ι
inst✝ : AddCommMonoid E
n : ι
h_mem : ∀ (ω : Ω), τ ω < n → τ ω ∈ Finset.Iio n
⊢ {a | n ≤ τ a}.indicator (u n) + ∑ i ∈ Finset.filter (fun x => x < n) (Finset.Iio n), {ω | τ ω = i}.indicator (u i) =
    {a | n ≤ τ a}.indicator (u n) + ∑ i ∈ Finset.Iio n, {ω | τ ω = i}.indicator (u i)

tactic: congr with i
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
μ : Measure Ω
τ σ : Ω → ι
E : Type u_4
p : ℝ≥0∞
u : ι → Ω → E
inst✝² : LinearOrder ι
inst✝¹ : LocallyFiniteOrderBot ι
inst✝ : AddCommMonoid E
n : ι
h_mem : ∀ (ω : Ω), τ ω < n → τ ω ∈ Finset.Iio n
⊢ {a | n ≤ τ a}.indicator (u n) + ∑ i ∈ Finset.filter (fun x => x < n) (Finset.Iio n), {ω | τ ω = i}.indicator (u i) =
    {a | n ≤ τ a}.indicator (u n) + ∑ i ∈ Finset.Iio n, {ω | τ ω = i}.indicator (u i)
state_after: case e_a.e_s.a
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
μ : Measure Ω
τ σ : Ω → ι
E : Type u_4
p : ℝ≥0∞
u : ι → Ω → E
inst✝² : LinearOrder ι
inst✝¹ : LocallyFiniteOrderBot ι
inst✝ : AddCommMonoid E
n : ι
h_mem : ∀ (ω : Ω), τ ω < n → τ ω ∈ Finset.Iio n
i : ι
⊢ i ∈ Finset.filter (fun x => x < n) (Finset.Iio n) ↔ i ∈ Finset.Iio n

tactic: simp
state_before: case e_a.e_s.a
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
μ : Measure Ω
τ σ : Ω → ι
E : Type u_4
p : ℝ≥0∞
u : ι → Ω → E
inst✝² : LinearOrder ι
inst✝¹ : LocallyFiniteOrderBot ι
inst✝ : AddCommMonoid E
n : ι
h_mem : ∀ (ω : Ω), τ ω < n → τ ω ∈ Finset.Iio n
i : ι
⊢ i ∈ Finset.filter (fun x => x < n) (Finset.Iio n) ↔ i ∈ Finset.Iio n
state_after: no goals
Theorem: IsCyclotomicExtension.aeval_zeta
File: Mathlib/NumberTheory/Cyclotomic/PrimitiveRoots.lean

tactic: rw [aeval_def, ← eval_map, ← IsRoot.def, map_cyclotomic, isRoot_cyclotomic_iff]
state_before: p n : ℕ+
A : Type w
B : Type z
K : Type u
L : Type v
C : Type w
inst✝⁵ : CommRing A
inst✝⁴ : CommRing B
inst✝³ : Algebra A B
inst✝² : IsCyclotomicExtension {n} A B
inst✝¹ : IsDomain B
inst✝ : NeZero ↑↑n
⊢ (aeval (zeta n A B)) (cyclotomic (↑n) A) = 0
state_after: p n : ℕ+
A : Type w
B : Type z
K : Type u
L : Type v
C : Type w
inst✝⁵ : CommRing A
inst✝⁴ : CommRing B
inst✝³ : Algebra A B
inst✝² : IsCyclotomicExtension {n} A B
inst✝¹ : IsDomain B
inst✝ : NeZero ↑↑n
⊢ IsPrimitiveRoot (zeta n A B) ↑n

tactic: exact zeta_spec n A B
state_before: p n : ℕ+
A : Type w
B : Type z
K : Type u
L : Type v
C : Type w
inst✝⁵ : CommRing A
inst✝⁴ : CommRing B
inst✝³ : Algebra A B
inst✝² : IsCyclotomicExtension {n} A B
inst✝¹ : IsDomain B
inst✝ : NeZero ↑↑n
⊢ IsPrimitiveRoot (zeta n A B) ↑n
state_after: no goals
Theorem: CategoryTheory.ShiftedHom.zero_comp
File: Mathlib/CategoryTheory/Shift/ShiftedHom.lean

tactic: rw [comp, Limits.zero_comp]
state_before: C : Type u_1
inst✝³ : Category.{u_3, u_1} C
M : Type u_2
inst✝² : AddMonoid M
inst✝¹ : HasShift C M
X Y Z T : C
inst✝ : Preadditive C
a b c : M
β : ShiftedHom Y Z b
h : b + a = c
⊢ comp 0 β h = 0
state_after: no goals
Theorem: ModuleCat.exact_iff
File: Mathlib/Algebra/Category/ModuleCat/Abelian.lean

tactic: rw [abelian.exact_iff' f g (kernelIsLimit _) (cokernelIsColimit _)]
state_before: R : Type u
inst✝ : Ring R
M N : ModuleCat R
f : M ⟶ N
O : ModuleCat R
g : N ⟶ O
⊢ Exact f g ↔ range f = ker g
state_after: R : Type u
inst✝ : Ring R
M N : ModuleCat R
f : M ⟶ N
O : ModuleCat R
g : N ⟶ O
⊢ f ≫ g = 0 ∧ Fork.ι (kernelCone g) ≫ Cofork.π (cokernelCocone f) = 0 ↔ range f = ker g

tactic: exact
  ⟨fun h => le_antisymm (range_le_ker_iff.2 h.1) (ker_le_range_iff.2 h.2), fun h =>
    ⟨range_le_ker_iff.1 <| le_of_eq h, ker_le_range_iff.1 <| le_of_eq h.symm⟩⟩
state_before: R : Type u
inst✝ : Ring R
M N : ModuleCat R
f : M ⟶ N
O : ModuleCat R
g : N ⟶ O
⊢ f ≫ g = 0 ∧ Fork.ι (kernelCone g) ≫ Cofork.π (cokernelCocone f) = 0 ↔ range f = ker g
state_after: no goals
Theorem: AList.insert_union
File: Mathlib/Data/List/AList.lean

tactic: ext
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b : β a
s₁ s₂ : AList β
⊢ insert a b (s₁ ∪ s₂) = insert a b s₁ ∪ s₂
state_after: case a.h.a
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b : β a
s₁ s₂ : AList β
n✝ : ℕ
a✝ : Sigma β
⊢ a✝ ∈ (insert a b (s₁ ∪ s₂)).entries[n✝]? ↔ a✝ ∈ (insert a b s₁ ∪ s₂).entries[n✝]?

tactic: simp
state_before: case a.h.a
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b : β a
s₁ s₂ : AList β
n✝ : ℕ
a✝ : Sigma β
⊢ a✝ ∈ (insert a b (s₁ ∪ s₂)).entries[n✝]? ↔ a✝ ∈ (insert a b s₁ ∪ s₂).entries[n✝]?
state_after: no goals
Theorem: MeasureTheory.IsSetSemiring.empty_not_mem_diffFinset₀
File: Mathlib/MeasureTheory/SetSemiring.lean

tactic: classical
simp only [diffFinset₀, mem_sdiff, Finset.mem_singleton, eq_self_iff_true, not_true,
  and_false_iff, not_false_iff]
state_before: α : Type u_1
C : Set (Set α)
s t : Set α
I : Finset (Set α)
hC : IsSetSemiring C
hs : s ∈ C
hI : ↑I ⊆ C
⊢ ∅ ∉ hC.diffFinset₀ hs hI
state_after: no goals

tactic: simp only [diffFinset₀, mem_sdiff, Finset.mem_singleton, eq_self_iff_true, not_true,
  and_false_iff, not_false_iff]
state_before: α : Type u_1
C : Set (Set α)
s t : Set α
I : Finset (Set α)
hC : IsSetSemiring C
hs : s ∈ C
hI : ↑I ⊆ C
⊢ ∅ ∉ hC.diffFinset₀ hs hI
state_after: no goals
Theorem: Matrix.det_invOf
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: letI := detInvertibleOfInvertible A
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝⁴ : Fintype n
inst✝³ : DecidableEq n
inst✝² : CommRing α
A B : Matrix n n α
inst✝¹ : Invertible A
inst✝ : Invertible A.det
⊢ (⅟A).det = ⅟A.det
state_after: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝⁴ : Fintype n
inst✝³ : DecidableEq n
inst✝² : CommRing α
A B : Matrix n n α
inst✝¹ : Invertible A
inst✝ : Invertible A.det
this : Invertible A.det := A.detInvertibleOfInvertible
⊢ (⅟A).det = ⅟A.det

tactic: convert (rfl : _ = ⅟ A.det)
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝⁴ : Fintype n
inst✝³ : DecidableEq n
inst✝² : CommRing α
A B : Matrix n n α
inst✝¹ : Invertible A
inst✝ : Invertible A.det
this : Invertible A.det := A.detInvertibleOfInvertible
⊢ (⅟A).det = ⅟A.det
state_after: no goals
Theorem: Ordinal.deriv_eq_id_of_nfp_eq_id
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

tactic: simp [h]
state_before: f✝ : Ordinal.{u} → Ordinal.{u}
f : Ordinal.{u_1} → Ordinal.{u_1}
h : nfp f = id
⊢ deriv f 0 = id 0 ∧ ∀ (a : Ordinal.{u_1}), deriv f a = id a → deriv f (succ a) = id (succ a)
state_after: no goals
Theorem: ModP.preVal_mk
File: Mathlib/RingTheory/Perfection.lean

tactic: obtain ⟨r, hr⟩ : ∃ (a : O), a * (p : O) = (Quotient.mk'' x).out' - x :=
  Ideal.mem_span_singleton'.1 <| Ideal.Quotient.eq.1 <| Quotient.sound' <| Quotient.mk_out' _
state_before: K : Type u₁
inst✝² : Field K
v : Valuation K ℝ≥0
O : Type u₂
inst✝¹ : CommRing O
inst✝ : Algebra O K
hv : v.Integers O
p : ℕ
hp : Fact (Nat.Prime p)
hvp : Fact (v ↑p ≠ 1)
x : O
hx : (Ideal.Quotient.mk (Ideal.span {↑p})) x ≠ 0
⊢ preVal K v O hv p ((Ideal.Quotient.mk (Ideal.span {↑p})) x) = v ((algebraMap O K) x)
state_after: case intro
K : Type u₁
inst✝² : Field K
v : Valuation K ℝ≥0
O : Type u₂
inst✝¹ : CommRing O
inst✝ : Algebra O K
hv : v.Integers O
p : ℕ
hp : Fact (Nat.Prime p)
hvp : Fact (v ↑p ≠ 1)
x : O
hx : (Ideal.Quotient.mk (Ideal.span {↑p})) x ≠ 0
r : O
hr : r * ↑p = (Quotient.mk'' x).out' - x
⊢ preVal K v O hv p ((Ideal.Quotient.mk (Ideal.span {↑p})) x) = v ((algebraMap O K) x)

tactic: refine (if_neg hx).trans (v.map_eq_of_sub_lt <| lt_of_not_le ?_)
state_before: case intro
K : Type u₁
inst✝² : Field K
v : Valuation K ℝ≥0
O : Type u₂
inst✝¹ : CommRing O
inst✝ : Algebra O K
hv : v.Integers O
p : ℕ
hp : Fact (Nat.Prime p)
hvp : Fact (v ↑p ≠ 1)
x : O
hx : (Ideal.Quotient.mk (Ideal.span {↑p})) x ≠ 0
r : O
hr : r * ↑p = (Quotient.mk'' x).out' - x
⊢ preVal K v O hv p ((Ideal.Quotient.mk (Ideal.span {↑p})) x) = v ((algebraMap O K) x)
state_after: case intro
K : Type u₁
inst✝² : Field K
v : Valuation K ℝ≥0
O : Type u₂
inst✝¹ : CommRing O
inst✝ : Algebra O K
hv : v.Integers O
p : ℕ
hp : Fact (Nat.Prime p)
hvp : Fact (v ↑p ≠ 1)
x : O
hx : (Ideal.Quotient.mk (Ideal.span {↑p})) x ≠ 0
r : O
hr : r * ↑p = (Quotient.mk'' x).out' - x
⊢ ¬v ((algebraMap O K) x) ≤
      v ((algebraMap O K) (Quotient.out' ((Ideal.Quotient.mk (Ideal.span {↑p})) x)) - (algebraMap O K) x)

tactic: erw [← RingHom.map_sub, ← hr, hv.le_iff_dvd]
state_before: case intro
K : Type u₁
inst✝² : Field K
v : Valuation K ℝ≥0
O : Type u₂
inst✝¹ : CommRing O
inst✝ : Algebra O K
hv : v.Integers O
p : ℕ
hp : Fact (Nat.Prime p)
hvp : Fact (v ↑p ≠ 1)
x : O
hx : (Ideal.Quotient.mk (Ideal.span {↑p})) x ≠ 0
r : O
hr : r * ↑p = (Quotient.mk'' x).out' - x
⊢ ¬v ((algebraMap O K) x) ≤
      v ((algebraMap O K) (Quotient.out' ((Ideal.Quotient.mk (Ideal.span {↑p})) x)) - (algebraMap O K) x)
state_after: case intro
K : Type u₁
inst✝² : Field K
v : Valuation K ℝ≥0
O : Type u₂
inst✝¹ : CommRing O
inst✝ : Algebra O K
hv : v.Integers O
p : ℕ
hp : Fact (Nat.Prime p)
hvp : Fact (v ↑p ≠ 1)
x : O
hx : (Ideal.Quotient.mk (Ideal.span {↑p})) x ≠ 0
r : O
hr : r * ↑p = (Quotient.mk'' x).out' - x
⊢ ¬r * ↑p ∣ x

tactic: exact fun hprx =>
  hx (Ideal.Quotient.eq_zero_iff_mem.2 <| Ideal.mem_span_singleton.2 <| dvd_of_mul_left_dvd hprx)
state_before: case intro
K : Type u₁
inst✝² : Field K
v : Valuation K ℝ≥0
O : Type u₂
inst✝¹ : CommRing O
inst✝ : Algebra O K
hv : v.Integers O
p : ℕ
hp : Fact (Nat.Prime p)
hvp : Fact (v ↑p ≠ 1)
x : O
hx : (Ideal.Quotient.mk (Ideal.span {↑p})) x ≠ 0
r : O
hr : r * ↑p = (Quotient.mk'' x).out' - x
⊢ ¬r * ↑p ∣ x
state_after: no goals
Theorem: DFinsupp.sigmaCurry_add
File: Mathlib/Data/DFinsupp/Basic.lean

tactic: ext (i j)
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
κ : Type u_1
α : ι → Type u_2
δ : (i : ι) → α i → Type v
inst✝ : (i : ι) → (j : α i) → AddZeroClass (δ i j)
f g : Π₀ (i : (x : ι) × α x), δ i.fst i.snd
⊢ (f + g).sigmaCurry = f.sigmaCurry + g.sigmaCurry
state_after: case h.h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
κ : Type u_1
α : ι → Type u_2
δ : (i : ι) → α i → Type v
inst✝ : (i : ι) → (j : α i) → AddZeroClass (δ i j)
f g : Π₀ (i : (x : ι) × α x), δ i.fst i.snd
i : ι
j : α i
⊢ ((f + g).sigmaCurry i) j = ((f.sigmaCurry + g.sigmaCurry) i) j

tactic: rfl
state_before: case h.h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
κ : Type u_1
α : ι → Type u_2
δ : (i : ι) → α i → Type v
inst✝ : (i : ι) → (j : α i) → AddZeroClass (δ i j)
f g : Π₀ (i : (x : ι) × α x), δ i.fst i.snd
i : ι
j : α i
⊢ ((f + g).sigmaCurry i) j = ((f.sigmaCurry + g.sigmaCurry) i) j
state_after: no goals
Theorem: CategoryTheory.MorphismProperty.isoClosure_respectsIso
File: Mathlib/CategoryTheory/MorphismProperty/Basic.lean

tactic: simp
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u_1
inst✝ : Category.{?u.6536, u_1} D
P : MorphismProperty C
X✝ Y✝ Z✝ : C
e : X✝ ≅ Y✝
f : Y✝ ⟶ Z✝
x✝ : P.isoClosure f
w✝¹ w✝ : C
f' : w✝¹ ⟶ w✝
hf' : P f'
iso : Arrow.mk f' ≅ Arrow.mk f
⊢ (asIso iso.hom.left ≪≫ e.symm).hom ≫ (Arrow.mk (e.hom ≫ f)).hom = (Arrow.mk f').hom ≫ (asIso iso.hom.right).hom
state_after: no goals

tactic: simp
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u_1
inst✝ : Category.{?u.6536, u_1} D
P : MorphismProperty C
X✝ Y✝ Z✝ : C
e : Y✝ ≅ Z✝
f : X✝ ⟶ Y✝
x✝ : P.isoClosure f
w✝¹ w✝ : C
f' : w✝¹ ⟶ w✝
hf' : P f'
iso : Arrow.mk f' ≅ Arrow.mk f
⊢ (asIso iso.hom.left).hom ≫ (Arrow.mk (f ≫ e.hom)).hom = (Arrow.mk f').hom ≫ (asIso iso.hom.right ≪≫ e).hom
state_after: no goals
Theorem: Polynomial.eraseLead_ne_zero
File: Mathlib/Algebra/Polynomial/EraseLead.lean

tactic: rw [Ne, ← card_support_eq_zero, eraseLead_support]
state_before: R : Type u_1
inst✝ : Semiring R
f : R[X]
f0 : 2 ≤ f.support.card
⊢ f.eraseLead ≠ 0
state_after: R : Type u_1
inst✝ : Semiring R
f : R[X]
f0 : 2 ≤ f.support.card
⊢ ¬(f.support.erase f.natDegree).card = 0

tactic: exact
  (zero_lt_one.trans_le <| (tsub_le_tsub_right f0 1).trans Finset.pred_card_le_card_erase).ne.symm
state_before: R : Type u_1
inst✝ : Semiring R
f : R[X]
f0 : 2 ≤ f.support.card
⊢ ¬(f.support.erase f.natDegree).card = 0
state_after: no goals
Theorem: norm_mul_le'
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: simpa [dist_eq_norm_div] using dist_triangle a 1 b⁻¹
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a✝ a₁ a₂ b✝ b₁ b₂ : E
r r₁ r₂ : ℝ
a b : E
⊢ ‖a * b‖ ≤ ‖a‖ + ‖b‖
state_after: no goals
Theorem: Set.univ_pow
File: Mathlib/Data/Set/Pointwise/Basic.lean

tactic: rw [pow_succ, univ_pow n.succ_ne_zero, univ_mul_univ]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Monoid α
s t : Set α
a : α
m n✝ n : ℕ
x✝ : n + 2 ≠ 0
⊢ univ ^ (n + 2) = univ
state_after: no goals
Theorem: Real.cos_pi_div_six
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: rw [show (6 : ℝ) = 3 * 2 by norm_num, div_mul_eq_div_div, cos_half, cos_pi_div_three, one_add_div,
  ← div_mul_eq_div_div, two_add_one_eq_three, sqrt_div, sqrt_mul_self] <;> linarith [pi_pos]
state_before: x : ℝ
⊢ cos (π / 6) = √3 / 2
state_after: no goals

tactic: norm_num
state_before: x : ℝ
⊢ 6 = 3 * 2
state_after: no goals
Theorem: ENNReal.mul_div_mul_right
File: Mathlib/Data/ENNReal/Inv.lean

tactic: rw [div_eq_mul_inv, div_eq_mul_inv, ENNReal.mul_inv (Or.inr hc') (Or.inr hc), mul_mul_mul_comm,
  ENNReal.mul_inv_cancel hc hc', mul_one]
state_before: a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a b : ℝ≥0∞
hc : c ≠ 0
hc' : c ≠ ⊤
⊢ a * c / (b * c) = a / b
state_after: no goals
Theorem: TypeVec.prod_map_id
File: Mathlib/Data/TypeVec.lean

tactic: ext i x : 2
state_before: n : ℕ
α β : TypeVec.{u_1} n
⊢ (id ⊗' id) = id
state_after: case a.h
n : ℕ
α β : TypeVec.{u_1} n
i : Fin2 n
x : (α ⊗ β) i
⊢ (id ⊗' id) i x = id i x

tactic: induction i <;> simp only [TypeVec.prod.map, *, dropFun_id]
state_before: case a.h
n : ℕ
α β : TypeVec.{u_1} n
i : Fin2 n
x : (α ⊗ β) i
⊢ (id ⊗' id) i x = id i x
state_after: case a.h.fz
n n✝ : ℕ
α β : TypeVec.{u_1} (n✝ + 1)
x : (α ⊗ β) Fin2.fz
⊢ (id Fin2.fz x.1, id Fin2.fz x.2) = id Fin2.fz x

case a.h.fs
n n✝ : ℕ
a✝ : Fin2 n✝
a_ih✝ : ∀ {α β : TypeVec.{u_1} n✝} (x : (α ⊗ β) a✝), (id ⊗' id) a✝ x = id a✝ x
α β : TypeVec.{u_1} (n✝ + 1)
x : (α ⊗ β) a✝.fs
⊢ id a✝ x = id a✝.fs x

tactic: cases x
state_before: case a.h.fz
n n✝ : ℕ
α β : TypeVec.{u_1} (n✝ + 1)
x : (α ⊗ β) Fin2.fz
⊢ (id Fin2.fz x.1, id Fin2.fz x.2) = id Fin2.fz x

case a.h.fs
n n✝ : ℕ
a✝ : Fin2 n✝
a_ih✝ : ∀ {α β : TypeVec.{u_1} n✝} (x : (α ⊗ β) a✝), (id ⊗' id) a✝ x = id a✝ x
α β : TypeVec.{u_1} (n✝ + 1)
x : (α ⊗ β) a✝.fs
⊢ id a✝ x = id a✝.fs x
state_after: case a.h.fz.mk
n n✝ : ℕ
α β : TypeVec.{u_1} (n✝ + 1)
fst✝ : α.last
snd✝ : β.last
⊢ (id Fin2.fz (fst✝, snd✝).1, id Fin2.fz (fst✝, snd✝).2) = id Fin2.fz (fst✝, snd✝)

case a.h.fs
n n✝ : ℕ
a✝ : Fin2 n✝
a_ih✝ : ∀ {α β : TypeVec.{u_1} n✝} (x : (α ⊗ β) a✝), (id ⊗' id) a✝ x = id a✝ x
α β : TypeVec.{u_1} (n✝ + 1)
x : (α ⊗ β) a✝.fs
⊢ id a✝ x = id a✝.fs x

tactic: rfl
state_before: case a.h.fz.mk
n n✝ : ℕ
α β : TypeVec.{u_1} (n✝ + 1)
fst✝ : α.last
snd✝ : β.last
⊢ (id Fin2.fz (fst✝, snd✝).1, id Fin2.fz (fst✝, snd✝).2) = id Fin2.fz (fst✝, snd✝)
state_after: no goals

tactic: rfl
state_before: case a.h.fs
n n✝ : ℕ
a✝ : Fin2 n✝
a_ih✝ : ∀ {α β : TypeVec.{u_1} n✝} (x : (α ⊗ β) a✝), (id ⊗' id) a✝ x = id a✝ x
α β : TypeVec.{u_1} (n✝ + 1)
x : (α ⊗ β) a✝.fs
⊢ id a✝ x = id a✝.fs x
state_after: no goals
Theorem: RelEmbedding.image_minimals_eq
File: Mathlib/Order/Minimal.lean

tactic: rw [image_minimals_of_rel_iff_rel]
state_before: α : Type u_1
β : Type u_2
r✝ r₁ r₂ : α → α → Prop
s✝ t : Set α
a b : α
inst✝ : PartialOrder α
f✝ : α → β
r : α → α → Prop
s : β → β → Prop
f : r ↪r s
x : Set α
⊢ ⇑f '' minimals r x = minimals s (⇑f '' x)
state_after: α : Type u_1
β : Type u_2
r✝ r₁ r₂ : α → α → Prop
s✝ t : Set α
a b : α
inst✝ : PartialOrder α
f✝ : α → β
r : α → α → Prop
s : β → β → Prop
f : r ↪r s
x : Set α
⊢ ∀ ⦃a a' : α⦄, a ∈ x → a' ∈ x → (r a a' ↔ s (f a) (f a'))

tactic: simp [f.map_rel_iff]
state_before: α : Type u_1
β : Type u_2
r✝ r₁ r₂ : α → α → Prop
s✝ t : Set α
a b : α
inst✝ : PartialOrder α
f✝ : α → β
r : α → α → Prop
s : β → β → Prop
f : r ↪r s
x : Set α
⊢ ∀ ⦃a a' : α⦄, a ∈ x → a' ∈ x → (r a a' ↔ s (f a) (f a'))
state_after: no goals
Theorem: Matrix.fromBlocks_neg
File: Mathlib/Data/Matrix/Block.lean

tactic: ext i j
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
inst✝ : Neg R
A : Matrix n l R
B : Matrix n m R
C : Matrix o l R
D : Matrix o m R
⊢ -fromBlocks A B C D = fromBlocks (-A) (-B) (-C) (-D)
state_after: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
inst✝ : Neg R
A : Matrix n l R
B : Matrix n m R
C : Matrix o l R
D : Matrix o m R
i : n ⊕ o
j : l ⊕ m
⊢ (-fromBlocks A B C D) i j = fromBlocks (-A) (-B) (-C) (-D) i j

tactic: cases i <;> cases j <;> simp [fromBlocks]
state_before: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
inst✝ : Neg R
A : Matrix n l R
B : Matrix n m R
C : Matrix o l R
D : Matrix o m R
i : n ⊕ o
j : l ⊕ m
⊢ (-fromBlocks A B C D) i j = fromBlocks (-A) (-B) (-C) (-D) i j
state_after: no goals
Theorem: RingEquiv.coe_nonUnitalRingHom_inj_iff
File: Mathlib/Algebra/Ring/Equiv.lean

tactic: rw [h]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
R✝ : Type u_4
S✝ : Type u_5
S' : Type u_6
inst✝⁴ : NonUnitalNonAssocSemiring R✝
inst✝³ : NonUnitalNonAssocSemiring S✝
inst✝² : NonUnitalNonAssocSemiring S'
R : Type u_7
S : Type u_8
inst✝¹ : NonUnitalNonAssocSemiring R
inst✝ : NonUnitalNonAssocSemiring S
f g : R ≃+* S
h : f = g
⊢ ↑f = ↑g
state_after: no goals
Theorem: Real.volume_pi_ball
File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

tactic: simp only [MeasureTheory.volume_pi_ball a hr, volume_ball, Finset.prod_const]
state_before: ι : Type u_1
inst✝ : Fintype ι
a : ι → ℝ
r : ℝ
hr : 0 < r
⊢ volume (Metric.ball a r) = ofReal ((2 * r) ^ Fintype.card ι)
state_after: ι : Type u_1
inst✝ : Fintype ι
a : ι → ℝ
r : ℝ
hr : 0 < r
⊢ ofReal (2 * r) ^ Finset.univ.card = ofReal ((2 * r) ^ Fintype.card ι)

tactic: exact (ENNReal.ofReal_pow (mul_nonneg zero_le_two hr.le) _).symm
state_before: ι : Type u_1
inst✝ : Fintype ι
a : ι → ℝ
r : ℝ
hr : 0 < r
⊢ ofReal (2 * r) ^ Finset.univ.card = ofReal ((2 * r) ^ Fintype.card ι)
state_after: no goals
Theorem: MeasureTheory.Integrable.withDensityᵥ_trim_eq_integral
File: Mathlib/MeasureTheory/Measure/WithDensityVectorMeasure.lean

tactic: rw [VectorMeasure.trim_measurableSet_eq hm hi, withDensityᵥ_apply hf (hm _ hi)]
state_before: α : Type u_1
β : Type u_2
m✝ : MeasurableSpace α
μ✝ ν : Measure α
E : Type u_3
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f✝ g : α → E
m m0 : MeasurableSpace α
μ : Measure α
hm : m ≤ m0
f : α → ℝ
hf : Integrable f μ
i : Set α
hi : MeasurableSet i
⊢ ↑((μ.withDensityᵥ f).trim hm) i = ∫ (x : α) in i, f x ∂μ
state_after: no goals
Theorem: SemidirectProduct.map_comp_inl
File: Mathlib/GroupTheory/SemidirectProduct.lean

tactic: ext <;> simp
state_before: N : Type u_1
G : Type u_2
H : Type u_3
inst✝⁴ : Group N
inst✝³ : Group G
inst✝² : Group H
φ : G →* MulAut N
N₁ : Type u_4
G₁ : Type u_5
inst✝¹ : Group N₁
inst✝ : Group G₁
φ₁ : G₁ →* MulAut N₁
f₁ : N →* N₁
f₂ : G →* G₁
h : ∀ (g : G), f₁.comp (MulEquiv.toMonoidHom (φ g)) = (MulEquiv.toMonoidHom (φ₁ (f₂ g))).comp f₁
⊢ (map f₁ f₂ h).comp inl = inl.comp f₁
state_after: no goals
Theorem: Bool.not_ne_self
File: Mathlib/Data/Bool/Basic.lean

tactic: decide
state_before: ⊢ ∀ (b : Bool), (!b) ≠ b
state_after: no goals
Theorem: Finset.nnnorm_prod_le
File: Mathlib/Analysis/Normed/Field/Basic.lean

tactic: simp [NNReal.coe_prod]
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝² : SeminormedRing α✝
α : Type u_5
inst✝¹ : NormedCommRing α
inst✝ : NormOneClass α
s : Finset ι
f : ι → α
⊢ ∏ i ∈ s, ‖f i‖ = (fun a => ↑a) (∏ i ∈ s, ‖f i‖₊)
state_after: no goals
Theorem: CategoryTheory.Limits.limitFlipCompLimIsoLimitCompLim_hom_π_π
File: Mathlib/CategoryTheory/Limits/Fubini.lean

tactic: dsimp [limitFlipCompLimIsoLimitCompLim]
state_before: J K : Type v
inst✝⁶ : SmallCategory J
inst✝⁵ : SmallCategory K
C : Type u
inst✝⁴ : Category.{v, u} C
F : J ⥤ K ⥤ C
inst✝³ : HasLimitsOfShape J C
inst✝² : HasLimitsOfShape K C
inst✝¹ : HasLimitsOfShape (J × K) C
inst✝ : HasLimitsOfShape (K × J) C
j : J
k : K
⊢ (limitFlipCompLimIsoLimitCompLim F).hom ≫ limit.π (F ⋙ lim) j ≫ limit.π (F.obj j) k =
    limit.π (F.flip ⋙ lim) k ≫ limit.π (F.flip.obj k) j
state_after: J K : Type v
inst✝⁶ : SmallCategory J
inst✝⁵ : SmallCategory K
C : Type u
inst✝⁴ : Category.{v, u} C
F : J ⥤ K ⥤ C
inst✝³ : HasLimitsOfShape J C
inst✝² : HasLimitsOfShape K C
inst✝¹ : HasLimitsOfShape (J × K) C
inst✝ : HasLimitsOfShape (K × J) C
j : J
k : K
⊢ ((limitUncurryIsoLimitCompLim F.flip).inv ≫
        (HasLimit.isoOfNatIso (uncurryObjFlip F)).hom ≫
          (HasLimit.isoOfEquivalence (Prod.braiding K J)
                (NatIso.ofComponents (fun x => Iso.refl ((F.obj x.2).obj x.1)) ⋯)).hom ≫
            (limitUncurryIsoLimitCompLim F).hom) ≫
      limit.π (F ⋙ lim) j ≫ limit.π (F.obj j) k =
    limit.π (F.flip ⋙ lim) k ≫ limit.π (F.flip.obj k) j

tactic: simp
state_before: J K : Type v
inst✝⁶ : SmallCategory J
inst✝⁵ : SmallCategory K
C : Type u
inst✝⁴ : Category.{v, u} C
F : J ⥤ K ⥤ C
inst✝³ : HasLimitsOfShape J C
inst✝² : HasLimitsOfShape K C
inst✝¹ : HasLimitsOfShape (J × K) C
inst✝ : HasLimitsOfShape (K × J) C
j : J
k : K
⊢ ((limitUncurryIsoLimitCompLim F.flip).inv ≫
        (HasLimit.isoOfNatIso (uncurryObjFlip F)).hom ≫
          (HasLimit.isoOfEquivalence (Prod.braiding K J)
                (NatIso.ofComponents (fun x => Iso.refl ((F.obj x.2).obj x.1)) ⋯)).hom ≫
            (limitUncurryIsoLimitCompLim F).hom) ≫
      limit.π (F ⋙ lim) j ≫ limit.π (F.obj j) k =
    limit.π (F.flip ⋙ lim) k ≫ limit.π (F.flip.obj k) j
state_after: no goals
Theorem: Complex.div_I
File: Mathlib/Data/Complex/Basic.lean

tactic: simp [mul_assoc]
state_before: z : ℂ
⊢ -(z * I) * I = z
state_after: no goals
Theorem: Complex.cpow_sub
File: Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean

tactic: rw [sub_eq_add_neg, cpow_add _ _ hx, cpow_neg, div_eq_mul_inv]
state_before: x y z : ℂ
hx : x ≠ 0
⊢ x ^ (y - z) = x ^ y / x ^ z
state_after: no goals