1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Set.Ioo_inter_Iio
File: Mathlib/Order/Interval/Set/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
a a₁ a₂ b b₁ b₂ c d : α
⊢ Ioo a b ∩ Iio c = Ioo a (min b c)
state_after: case h
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
a a₁ a₂ b b₁ b₂ c d x✝ : α
⊢ x✝ ∈ Ioo a b ∩ Iio c ↔ x✝ ∈ Ioo a (min b c)

tactic: simp_rw [mem_inter_iff, mem_Ioo, mem_Iio, lt_min_iff, and_assoc]
state_before: case h
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
a a₁ a₂ b b₁ b₂ c d x✝ : α
⊢ x✝ ∈ Ioo a b ∩ Iio c ↔ x✝ ∈ Ioo a (min b c)
state_after: no goals
Theorem: Compactum.continuous_of_hom
File: Mathlib/Topology/Category/Compactum.lean

tactic: rw [continuous_iff_ultrafilter]
state_before: X Y : Compactum
f : X ⟶ Y
⊢ Continuous f.f
state_after: X Y : Compactum
f : X ⟶ Y
⊢ ∀ (x : X.A) (g : Ultrafilter X.A), ↑g ≤ 𝓝 x → Tendsto f.f (↑g) (𝓝 (f.f x))

tactic: intro x g h
state_before: X Y : Compactum
f : X ⟶ Y
⊢ ∀ (x : X.A) (g : Ultrafilter X.A), ↑g ≤ 𝓝 x → Tendsto f.f (↑g) (𝓝 (f.f x))
state_after: X Y : Compactum
f : X ⟶ Y
x : X.A
g : Ultrafilter X.A
h : ↑g ≤ 𝓝 x
⊢ Tendsto f.f (↑g) (𝓝 (f.f x))

tactic: rw [Tendsto, ← coe_map]
state_before: X Y : Compactum
f : X ⟶ Y
x : X.A
g : Ultrafilter X.A
h : ↑g ≤ 𝓝 x
⊢ Tendsto f.f (↑g) (𝓝 (f.f x))
state_after: X Y : Compactum
f : X ⟶ Y
x : X.A
g : Ultrafilter X.A
h : ↑g ≤ 𝓝 x
⊢ ↑(Ultrafilter.map f.f g) ≤ 𝓝 (f.f x)

tactic: apply le_nhds_of_str_eq
state_before: X Y : Compactum
f : X ⟶ Y
x : X.A
g : Ultrafilter X.A
h : ↑g ≤ 𝓝 x
⊢ ↑(Ultrafilter.map f.f g) ≤ 𝓝 (f.f x)
state_after: case a
X Y : Compactum
f : X ⟶ Y
x : X.A
g : Ultrafilter X.A
h : ↑g ≤ 𝓝 x
⊢ Y.str (Ultrafilter.map f.f g) = f.f x

tactic: rw [← str_hom_commute, str_eq_of_le_nhds _ x _]
state_before: case a
X Y : Compactum
f : X ⟶ Y
x : X.A
g : Ultrafilter X.A
h : ↑g ≤ 𝓝 x
⊢ Y.str (Ultrafilter.map f.f g) = f.f x
state_after: X Y : Compactum
f : X ⟶ Y
x : X.A
g : Ultrafilter X.A
h : ↑g ≤ 𝓝 x
⊢ ↑g ≤ 𝓝 x

tactic: apply h
state_before: X Y : Compactum
f : X ⟶ Y
x : X.A
g : Ultrafilter X.A
h : ↑g ≤ 𝓝 x
⊢ ↑g ≤ 𝓝 x
state_after: no goals
Theorem: Batteries.UnionFind.rankD_push
File: .lake/packages/batteries/Batteries/Data/UnionFind/Lemmas.lean

tactic: simp [rankD]
state_before: a : Nat
arr : Array UFNode
⊢ rankD (arr.push { parent := arr.size, rank := 0 }) a = rankD arr a
state_after: a : Nat
arr : Array UFNode
⊢ (if h : a < arr.size + 1 then (arr.push { parent := arr.size, rank := 0 })[a].rank else 0) =
    if h : a < arr.size then arr[a].rank else 0

tactic: split <;> split <;> try simp [Array.get_push, *]
state_before: a : Nat
arr : Array UFNode
⊢ (if h : a < arr.size + 1 then (arr.push { parent := arr.size, rank := 0 })[a].rank else 0) =
    if h : a < arr.size then arr[a].rank else 0
state_after: case isFalse.isTrue
a : Nat
arr : Array UFNode
h✝¹ : ¬a < arr.size + 1
h✝ : a < arr.size
⊢ 0 = arr[a].rank

tactic: next h1 h2 => cases h1 (Nat.lt_succ_of_lt h2)
state_before: case isFalse.isTrue
a : Nat
arr : Array UFNode
h✝¹ : ¬a < arr.size + 1
h✝ : a < arr.size
⊢ 0 = arr[a].rank
state_after: no goals

tactic: simp [Array.get_push, *]
state_before: case isFalse.isFalse
a : Nat
arr : Array UFNode
h✝¹ : ¬a < arr.size + 1
h✝ : ¬a < arr.size
⊢ 0 = 0
state_after: no goals

tactic: cases h1 (Nat.lt_succ_of_lt h2)
state_before: a : Nat
arr : Array UFNode
h1 : ¬a < arr.size + 1
h2 : a < arr.size
⊢ 0 = arr[a].rank
state_after: no goals
Theorem: mul_eq_one_iff_inv_eq
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [mul_eq_one_iff_eq_inv, inv_eq_iff_eq_inv]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
⊢ a * b = 1 ↔ a⁻¹ = b
state_after: no goals
Theorem: ArithmeticFunction.moebius_ne_zero_iff_eq_or
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: have := moebius_eq_or n
state_before: R : Type u_1
n : ℕ
⊢ μ n ≠ 0 ↔ μ n = 1 ∨ μ n = -1
state_after: R : Type u_1
n : ℕ
this : μ n = 0 ∨ μ n = 1 ∨ μ n = -1
⊢ μ n ≠ 0 ↔ μ n = 1 ∨ μ n = -1

tactic: aesop
state_before: R : Type u_1
n : ℕ
this : μ n = 0 ∨ μ n = 1 ∨ μ n = -1
⊢ μ n ≠ 0 ↔ μ n = 1 ∨ μ n = -1
state_after: no goals
Theorem: Matrix.linearIndependent_rows_iff_isUnit
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: rw [← transpose_transpose A, ← mulVec_injective_iff, ← coe_mulVecLin, mulVecLin_transpose,
  transpose_transpose, ← vecMul_injective_iff_isUnit, coe_vecMulLinear]
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝⁴ : DecidableEq m
inst✝³ : DecidableEq n
R : Type u_2
K : Type u_3
inst✝² : CommRing R
inst✝¹ : Field K
inst✝ : Fintype m
A : Matrix m m K
⊢ (LinearIndependent K fun i => A i) ↔ IsUnit A
state_after: no goals
Theorem: Sum.not_isRight
File: .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
x : α ⊕ β
⊢ ¬x.isRight = true ↔ x.isLeft = true
state_after: no goals
Theorem: SignType.neg_iff
File: Mathlib/Data/Sign.lean

tactic: cases a <;> decide
state_before: a : SignType
⊢ a < 0 ↔ a = -1
state_after: no goals
Theorem: Sym2.mem_map
File: Mathlib/Data/Sym/Sym2.lean

tactic: induction' z with x y
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : α → β
b : β
z : Sym2 α
⊢ b ∈ map f z ↔ ∃ a ∈ z, f a = b
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
f : α → β
b : β
x y : α
⊢ b ∈ map f s(x, y) ↔ ∃ a ∈ s(x, y), f a = b

tactic: simp only [map_pair_eq, mem_iff, exists_eq_or_imp, exists_eq_left]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
f : α → β
b : β
x y : α
⊢ b ∈ map f s(x, y) ↔ ∃ a ∈ s(x, y), f a = b
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
f : α → β
b : β
x y : α
⊢ b = f x ∨ b = f y ↔ f x = b ∨ f y = b

tactic: aesop
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
f : α → β
b : β
x y : α
⊢ b = f x ∨ b = f y ↔ f x = b ∨ f y = b
state_after: no goals
Theorem: MeasureTheory.SignedMeasure.singularPart_smul_nnreal
File: Mathlib/MeasureTheory/Decomposition/SignedLebesgue.lean

tactic: rw [singularPart, singularPart, smul_sub, ← toSignedMeasure_smul, ← toSignedMeasure_smul]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t s : SignedMeasure α
μ : Measure α
r : ℝ≥0
⊢ (r • s).singularPart μ = r • s.singularPart μ
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t s : SignedMeasure α
μ : Measure α
r : ℝ≥0
⊢ ((r • s).toJordanDecomposition.posPart.singularPart μ).toSignedMeasure -
      ((r • s).toJordanDecomposition.negPart.singularPart μ).toSignedMeasure =
    (r • s.toJordanDecomposition.posPart.singularPart μ).toSignedMeasure -
      (r • s.toJordanDecomposition.negPart.singularPart μ).toSignedMeasure
Theorem: Ordinal.mul_pos
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: simpa only [mul_zero] using mul_lt_mul_of_pos_left h₂ h₁
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal.{u_4}
h₁ : 0 < a
h₂ : 0 < b
⊢ 0 < a * b
state_after: no goals
Theorem: Stream'.tail_inits
File: Mathlib/Data/Stream/Init.lean

tactic: unfold inits
state_before: α : Type u
β : Type v
δ : Type w
s : Stream' α
⊢ s.inits.tail = initsCore [s.head, s.tail.head] s.tail.tail
state_after: α : Type u
β : Type v
δ : Type w
s : Stream' α
⊢ (initsCore [s.head] s.tail).tail = initsCore [s.head, s.tail.head] s.tail.tail

tactic: rw [inits_core_eq]
state_before: α : Type u
β : Type v
δ : Type w
s : Stream' α
⊢ (initsCore [s.head] s.tail).tail = initsCore [s.head, s.tail.head] s.tail.tail
state_after: α : Type u
β : Type v
δ : Type w
s : Stream' α
⊢ ([s.head] :: initsCore ([s.head] ++ [s.tail.head]) s.tail.tail).tail = initsCore [s.head, s.tail.head] s.tail.tail

tactic: rfl
state_before: α : Type u
β : Type v
δ : Type w
s : Stream' α
⊢ ([s.head] :: initsCore ([s.head] ++ [s.tail.head]) s.tail.tail).tail = initsCore [s.head, s.tail.head] s.tail.tail
state_after: no goals
Theorem: ValuationRing.range_algebraMap_eq
File: Mathlib/RingTheory/Valuation/ValuationRing.lean

tactic: ext
state_before: A : Type u
inst✝⁵ : CommRing A
K : Type v
inst✝⁴ : Field K
inst✝³ : Algebra A K
inst✝² : IsDomain A
inst✝¹ : ValuationRing A
inst✝ : IsFractionRing A K
⊢ (valuation A K).integer = (algebraMap A K).range
state_after: case h
A : Type u
inst✝⁵ : CommRing A
K : Type v
inst✝⁴ : Field K
inst✝³ : Algebra A K
inst✝² : IsDomain A
inst✝¹ : ValuationRing A
inst✝ : IsFractionRing A K
x✝ : K
⊢ x✝ ∈ (valuation A K).integer ↔ x✝ ∈ (algebraMap A K).range

tactic: exact mem_integer_iff _ _ _
state_before: case h
A : Type u
inst✝⁵ : CommRing A
K : Type v
inst✝⁴ : Field K
inst✝³ : Algebra A K
inst✝² : IsDomain A
inst✝¹ : ValuationRing A
inst✝ : IsFractionRing A K
x✝ : K
⊢ x✝ ∈ (valuation A K).integer ↔ x✝ ∈ (algebraMap A K).range
state_after: no goals
Theorem: Set.card_ne_eq
File: Mathlib/Data/Set/Finite.lean

tactic: haveI := Classical.decEq α
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝¹ : Fintype α
a : α
inst✝ : Fintype ↑{x | x ≠ a}
⊢ Fintype.card ↑{x | x ≠ a} = Fintype.card α - 1
state_after: α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝¹ : Fintype α
a : α
inst✝ : Fintype ↑{x | x ≠ a}
this : DecidableEq α
⊢ Fintype.card ↑{x | x ≠ a} = Fintype.card α - 1

tactic: rw [← toFinset_card, toFinset_setOf, Finset.filter_ne',
  Finset.card_erase_of_mem (Finset.mem_univ _), Finset.card_univ]
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝¹ : Fintype α
a : α
inst✝ : Fintype ↑{x | x ≠ a}
this : DecidableEq α
⊢ Fintype.card ↑{x | x ≠ a} = Fintype.card α - 1
state_after: no goals
Theorem: RCLike.im_eq_conj_sub
File: Mathlib/Analysis/RCLike/Basic.lean

tactic: rw [← neg_inj, ← ofReal_neg, ← I_mul_re, re_eq_add_conj, map_mul, conj_I, ← neg_div, ← mul_neg,
  neg_sub, mul_sub, neg_mul, sub_eq_add_neg]
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z : K
⊢ ↑(im z) = I * ((starRingEnd K) z - z) / 2
state_after: no goals
Theorem: CochainComplex.homOfDegreewiseSplit_f
File: Mathlib/Algebra/Homology/HomotopyCategory/DegreewiseSplit.lean

tactic: simp [homOfDegreewiseSplit, Cochain.rightShift_v _ _ _ _ _ _ _ _ rfl]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
S : ShortComplex (CochainComplex C ℤ)
σ : (n : ℤ) → (S.map (eval C (ComplexShape.up ℤ) n)).Splitting
n : ℤ
⊢ (homOfDegreewiseSplit S σ).f n = (↑(cocycleOfDegreewiseSplit S σ)).v n (n + 1) ⋯
state_after: no goals
Theorem: Set.one_lt_encard_iff
File: Mathlib/Data/Set/Card.lean

tactic: rw [← not_iff_not, not_exists, not_lt, encard_le_one_iff]
state_before: α : Type u_1
β : Type u_2
s t : Set α
⊢ 1 < s.encard ↔ ∃ a b, a ∈ s ∧ b ∈ s ∧ a ≠ b
state_after: α : Type u_1
β : Type u_2
s t : Set α
⊢ (∀ (a b : α), a ∈ s → b ∈ s → a = b) ↔ ∀ (x : α), ¬∃ b, x ∈ s ∧ b ∈ s ∧ x ≠ b

tactic: aesop
state_before: α : Type u_1
β : Type u_2
s t : Set α
⊢ (∀ (a b : α), a ∈ s → b ∈ s → a = b) ↔ ∀ (x : α), ¬∃ b, x ∈ s ∧ b ∈ s ∧ x ≠ b
state_after: no goals
Theorem: norm_image_of_norm_zero
File: Mathlib/Analysis/NormedSpace/OperatorNorm/Basic.lean

tactic: rw [← mem_closure_zero_iff_norm, ← specializes_iff_mem_closure, ← map_zero f] at *
state_before: 𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type u_3
E : Type u_4
Eₗ : Type u_5
F : Type u_6
Fₗ : Type u_7
G : Type u_8
Gₗ : Type u_9
𝓕 : Type u_10
inst✝¹⁶ : SeminormedAddCommGroup E
inst✝¹⁵ : SeminormedAddCommGroup Eₗ
inst✝¹⁴ : SeminormedAddCommGroup F
inst✝¹³ : SeminormedAddCommGroup Fₗ
inst✝¹² : SeminormedAddCommGroup G
inst✝¹¹ : SeminormedAddCommGroup Gₗ
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : NontriviallyNormedField 𝕜₂
inst✝⁸ : NontriviallyNormedField 𝕜₃
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : NormedSpace 𝕜 Eₗ
inst✝⁵ : NormedSpace 𝕜₂ F
inst✝⁴ : NormedSpace 𝕜 Fₗ
inst✝³ : NormedSpace 𝕜₃ G
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
σ₁₃ : 𝕜 →+* 𝕜₃
inst✝² : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝¹ : FunLike 𝓕 E F
inst✝ : SemilinearMapClass 𝓕 σ₁₂ E F
f : 𝓕
hf : Continuous ⇑f
x : E
hx : ‖x‖ = 0
⊢ ‖f x‖ = 0
state_after: 𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type u_3
E : Type u_4
Eₗ : Type u_5
F : Type u_6
Fₗ : Type u_7
G : Type u_8
Gₗ : Type u_9
𝓕 : Type u_10
inst✝¹⁶ : SeminormedAddCommGroup E
inst✝¹⁵ : SeminormedAddCommGroup Eₗ
inst✝¹⁴ : SeminormedAddCommGroup F
inst✝¹³ : SeminormedAddCommGroup Fₗ
inst✝¹² : SeminormedAddCommGroup G
inst✝¹¹ : SeminormedAddCommGroup Gₗ
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : NontriviallyNormedField 𝕜₂
inst✝⁸ : NontriviallyNormedField 𝕜₃
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : NormedSpace 𝕜 Eₗ
inst✝⁵ : NormedSpace 𝕜₂ F
inst✝⁴ : NormedSpace 𝕜 Fₗ
inst✝³ : NormedSpace 𝕜₃ G
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
σ₁₃ : 𝕜 →+* 𝕜₃
inst✝² : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝¹ : FunLike 𝓕 E F
inst✝ : SemilinearMapClass 𝓕 σ₁₂ E F
f : 𝓕
hf : Continuous ⇑f
x : E
hx : 0 ⤳ x
⊢ f 0 ⤳ f x

tactic: exact hx.map hf
state_before: 𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type u_3
E : Type u_4
Eₗ : Type u_5
F : Type u_6
Fₗ : Type u_7
G : Type u_8
Gₗ : Type u_9
𝓕 : Type u_10
inst✝¹⁶ : SeminormedAddCommGroup E
inst✝¹⁵ : SeminormedAddCommGroup Eₗ
inst✝¹⁴ : SeminormedAddCommGroup F
inst✝¹³ : SeminormedAddCommGroup Fₗ
inst✝¹² : SeminormedAddCommGroup G
inst✝¹¹ : SeminormedAddCommGroup Gₗ
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : NontriviallyNormedField 𝕜₂
inst✝⁸ : NontriviallyNormedField 𝕜₃
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : NormedSpace 𝕜 Eₗ
inst✝⁵ : NormedSpace 𝕜₂ F
inst✝⁴ : NormedSpace 𝕜 Fₗ
inst✝³ : NormedSpace 𝕜₃ G
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
σ₁₃ : 𝕜 →+* 𝕜₃
inst✝² : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝¹ : FunLike 𝓕 E F
inst✝ : SemilinearMapClass 𝓕 σ₁₂ E F
f : 𝓕
hf : Continuous ⇑f
x : E
hx : 0 ⤳ x
⊢ f 0 ⤳ f x
state_after: no goals
Theorem: Bornology.isBounded_sUnion
File: Mathlib/Topology/Bornology/Basic.lean

tactic: rw [sUnion_eq_biUnion, isBounded_biUnion hs]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
s : Set α
inst✝ : Bornology α
S : Set (Set α)
hs : S.Finite
⊢ IsBounded (⋃₀ S) ↔ ∀ s ∈ S, IsBounded s
state_after: no goals
Theorem: SetTheory.PGame.mulOption_symm
File: Mathlib/SetTheory/Game/Basic.lean

tactic: dsimp only [mulOption, quot_sub, quot_add]
state_before: x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ ⟦x.mulOption y i j⟧ = ⟦y.mulOption x j i⟧
state_after: x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ ⟦x.moveLeft i * y⟧ + ⟦x * y.moveLeft j⟧ - ⟦x.moveLeft i * y.moveLeft j⟧ =
    ⟦y.moveLeft j * x⟧ + ⟦y * x.moveLeft i⟧ - ⟦y.moveLeft j * x.moveLeft i⟧

tactic: rw [add_comm]
state_before: x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ ⟦x.moveLeft i * y⟧ + ⟦x * y.moveLeft j⟧ - ⟦x.moveLeft i * y.moveLeft j⟧ =
    ⟦y.moveLeft j * x⟧ + ⟦y * x.moveLeft i⟧ - ⟦y.moveLeft j * x.moveLeft i⟧
state_after: x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ ⟦x * y.moveLeft j⟧ + ⟦x.moveLeft i * y⟧ - ⟦x.moveLeft i * y.moveLeft j⟧ =
    ⟦y.moveLeft j * x⟧ + ⟦y * x.moveLeft i⟧ - ⟦y.moveLeft j * x.moveLeft i⟧

tactic: congr 1
state_before: x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ ⟦x * y.moveLeft j⟧ + ⟦x.moveLeft i * y⟧ - ⟦x.moveLeft i * y.moveLeft j⟧ =
    ⟦y.moveLeft j * x⟧ + ⟦y * x.moveLeft i⟧ - ⟦y.moveLeft j * x.moveLeft i⟧
state_after: case e_a
x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ ⟦x * y.moveLeft j⟧ + ⟦x.moveLeft i * y⟧ = ⟦y.moveLeft j * x⟧ + ⟦y * x.moveLeft i⟧

case e_a
x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ ⟦x.moveLeft i * y.moveLeft j⟧ = ⟦y.moveLeft j * x.moveLeft i⟧

tactic: on_goal 1 => congr 1
state_before: case e_a
x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ ⟦x * y.moveLeft j⟧ + ⟦x.moveLeft i * y⟧ = ⟦y.moveLeft j * x⟧ + ⟦y * x.moveLeft i⟧

case e_a
x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ ⟦x.moveLeft i * y.moveLeft j⟧ = ⟦y.moveLeft j * x.moveLeft i⟧
state_after: case e_a.e_a
x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ ⟦x * y.moveLeft j⟧ = ⟦y.moveLeft j * x⟧

case e_a.e_a
x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ ⟦x.moveLeft i * y⟧ = ⟦y * x.moveLeft i⟧

case e_a
x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ ⟦x.moveLeft i * y.moveLeft j⟧ = ⟦y.moveLeft j * x.moveLeft i⟧

tactic: all_goals rw [quot_mul_comm]
state_before: case e_a.e_a
x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ ⟦x * y.moveLeft j⟧ = ⟦y.moveLeft j * x⟧

case e_a.e_a
x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ ⟦x.moveLeft i * y⟧ = ⟦y * x.moveLeft i⟧

case e_a
x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ ⟦x.moveLeft i * y.moveLeft j⟧ = ⟦y.moveLeft j * x.moveLeft i⟧
state_after: no goals

tactic: congr 1
state_before: case e_a
x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ ⟦x * y.moveLeft j⟧ + ⟦x.moveLeft i * y⟧ = ⟦y.moveLeft j * x⟧ + ⟦y * x.moveLeft i⟧
state_after: case e_a.e_a
x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ ⟦x * y.moveLeft j⟧ = ⟦y.moveLeft j * x⟧

case e_a.e_a
x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ ⟦x.moveLeft i * y⟧ = ⟦y * x.moveLeft i⟧

tactic: rw [quot_mul_comm]
state_before: case e_a
x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ ⟦x.moveLeft i * y.moveLeft j⟧ = ⟦y.moveLeft j * x.moveLeft i⟧
state_after: no goals
Theorem: Metric.uniformSpace_eq_bot
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

tactic: simp only [uniformity_basis_dist.uniformSpace_eq_bot, mem_setOf_eq, not_lt]
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
⊢ PseudoMetricSpace.toUniformSpace = ⊥ ↔ ∃ r, 0 < r ∧ Pairwise fun x x_1 => r ≤ dist x x_1
state_after: no goals
Theorem: Submodule.map_equivMapOfInjective_symm_apply
File: Mathlib/Algebra/Module/Submodule/Map.lean

tactic: rw [← LinearEquiv.apply_symm_apply (equivMapOfInjective f i p) x, coe_equivMapOfInjective_apply,
  i.eq_iff, LinearEquiv.apply_symm_apply]
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
inst✝¹³ : Semiring R
inst✝¹² : Semiring R₂
inst✝¹¹ : Semiring R₃
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : AddCommMonoid M₂
inst✝⁸ : AddCommMonoid M₃
inst✝⁷ : Module R M
inst✝⁶ : Module R₂ M₂
inst✝⁵ : Module R₃ M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝⁴ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
p✝ p' : Submodule R M
q q' : Submodule R₂ M₂
x✝ : M
σ₂₁ : R₂ →+* R
inst✝³ : RingHomInvPair σ₁₂ σ₂₁
inst✝² : RingHomInvPair σ₂₁ σ₁₂
F : Type u_9
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F σ₁₂ M M₂
f : F
i : Injective ⇑f
p : Submodule R M
x : ↥(map f p)
⊢ f ↑((equivMapOfInjective f i p).symm x) = ↑x
state_after: no goals
Theorem: Nat.max_sq_add_min_le_pair
File: Mathlib/Data/Nat/Pairing.lean

tactic: rw [pair]
state_before: m n : ℕ
⊢ max m n ^ 2 + min m n ≤ pair m n
state_after: m n : ℕ
⊢ max m n ^ 2 + min m n ≤ if m < n then n * n + m else m * m + m + n

tactic: cases' lt_or_le m n with h h
state_before: m n : ℕ
⊢ max m n ^ 2 + min m n ≤ if m < n then n * n + m else m * m + m + n
state_after: case inl
m n : ℕ
h : m < n
⊢ max m n ^ 2 + min m n ≤ if m < n then n * n + m else m * m + m + n

case inr
m n : ℕ
h : n ≤ m
⊢ max m n ^ 2 + min m n ≤ if m < n then n * n + m else m * m + m + n

tactic: rw [if_neg h.not_lt, max_eq_left h, min_eq_right h, Nat.pow_two, Nat.add_assoc,
  Nat.add_le_add_iff_left]
state_before: case inr
m n : ℕ
h : n ≤ m
⊢ max m n ^ 2 + min m n ≤ if m < n then n * n + m else m * m + m + n
state_after: case inr
m n : ℕ
h : n ≤ m
⊢ n ≤ m + n

tactic: exact Nat.le_add_left _ _
state_before: case inr
m n : ℕ
h : n ≤ m
⊢ n ≤ m + n
state_after: no goals

tactic: rw [if_pos h, max_eq_right h.le, min_eq_left h.le, Nat.pow_two]
state_before: case inl
m n : ℕ
h : m < n
⊢ max m n ^ 2 + min m n ≤ if m < n then n * n + m else m * m + m + n
state_after: no goals
Theorem: CategoryTheory.StructuredArrow.mkPostcomp_id
File: Mathlib/CategoryTheory/Comma/StructuredArrow.lean

tactic: aesop_cat
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' Y'' : C
T T' : C ⥤ D
f : S ⟶ T.obj Y
⊢ mk f = mk (f ≫ T.map (𝟙 Y))
state_after: no goals

tactic: aesop_cat
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' Y'' : C
T T' : C ⥤ D
f : S ⟶ T.obj Y
⊢ mkPostcomp f (𝟙 Y) = eqToHom ⋯
state_after: no goals
Theorem: Subsingleton.pi_mulSingle_eq
File: Mathlib/Algebra/Group/Pi/Basic.lean

tactic: rw [Subsingleton.elim j i, Pi.mulSingle_eq_same]
state_before: I : Type u
α✝ : Type u_1
β : Type u_2
γ : Type u_3
f : I → Type v₁
g : I → Type v₂
h : I → Type v₃
x✝ y : (i : I) → f i
i✝ : I
α : Type u_4
inst✝² : DecidableEq I
inst✝¹ : Subsingleton I
inst✝ : One α
i : I
x : α
j : I
⊢ Pi.mulSingle i x j = x
state_after: no goals
Theorem: padicNorm.padicNorm_p
File: Mathlib/NumberTheory/Padics/PadicNorm.lean

tactic: simp [padicNorm, (pos_of_gt hp).ne', padicValNat.self hp]
state_before: p : ℕ
hp : 1 < p
⊢ padicNorm p ↑p = (↑p)⁻¹
state_after: no goals
Theorem: ZMod.natCast_toNat
File: Mathlib/Data/ZMod/Basic.lean

tactic: simp only [Int.cast_natCast, Int.toNat_natCast]
state_before: p n : ℕ
_h : 0 ≤ ↑n
⊢ ↑(↑n).toNat = ↑↑n
state_after: no goals

tactic: simp at h
state_before: p n : ℕ
h : 0 ≤ Int.negSucc n
⊢ ↑(Int.negSucc n).toNat = ↑(Int.negSucc n)
state_after: no goals
Theorem: MeasureTheory.measure_iUnion_eq_iSup'
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [← iUnion_accumulate]
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι✝ : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α✝
μ✝ μ₁ μ₂ : Measure α✝
s s₁ s₂ t : Set α✝
α : Type u_8
ι : Type u_9
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : Countable ι
inst✝¹ : Preorder ι
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
f : ι → Set α
hd : Directed (fun x x_1 => x ⊆ x_1) (Accumulate f)
⊢ μ (⋃ i, f i) = ⨆ i, μ (Accumulate f i)
state_after: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι✝ : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α✝
μ✝ μ₁ μ₂ : Measure α✝
s s₁ s₂ t : Set α✝
α : Type u_8
ι : Type u_9
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : Countable ι
inst✝¹ : Preorder ι
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
f : ι → Set α
hd : Directed (fun x x_1 => x ⊆ x_1) (Accumulate f)
⊢ μ (⋃ x, Accumulate f x) = ⨆ i, μ (Accumulate f i)

tactic: exact measure_iUnion_eq_iSup hd
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι✝ : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α✝
μ✝ μ₁ μ₂ : Measure α✝
s s₁ s₂ t : Set α✝
α : Type u_8
ι : Type u_9
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : Countable ι
inst✝¹ : Preorder ι
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
f : ι → Set α
hd : Directed (fun x x_1 => x ⊆ x_1) (Accumulate f)
⊢ μ (⋃ x, Accumulate f x) = ⨆ i, μ (Accumulate f i)
state_after: no goals

tactic: intro i j
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι✝ : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α✝
μ✝ μ₁ μ₂ : Measure α✝
s s₁ s₂ t : Set α✝
α : Type u_8
ι : Type u_9
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : Countable ι
inst✝¹ : Preorder ι
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
f : ι → Set α
⊢ Directed (fun x x_1 => x ⊆ x_1) (Accumulate f)
state_after: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι✝ : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α✝
μ✝ μ₁ μ₂ : Measure α✝
s s₁ s₂ t : Set α✝
α : Type u_8
ι : Type u_9
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : Countable ι
inst✝¹ : Preorder ι
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
f : ι → Set α
i j : ι
⊢ ∃ z,
    (fun x x_1 => x ⊆ x_1) (Accumulate f i) (Accumulate f z) ∧ (fun x x_1 => x ⊆ x_1) (Accumulate f j) (Accumulate f z)

tactic: exact ⟨k, biUnion_subset_biUnion_left fun l rli ↦ le_trans rli rik,
  biUnion_subset_biUnion_left fun l rlj ↦ le_trans rlj rjk⟩
state_before: case intro.intro
α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι✝ : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α✝
μ✝ μ₁ μ₂ : Measure α✝
s s₁ s₂ t : Set α✝
α : Type u_8
ι : Type u_9
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : Countable ι
inst✝¹ : Preorder ι
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
f : ι → Set α
i j k : ι
rik : i ≤ k
rjk : j ≤ k
⊢ ∃ z,
    (fun x x_1 => x ⊆ x_1) (Accumulate f i) (Accumulate f z) ∧ (fun x x_1 => x ⊆ x_1) (Accumulate f j) (Accumulate f z)
state_after: no goals