1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Function.IsFixedPt.preimage_iterate
File: Mathlib/Dynamics/FixedPoints/Basic.lean

tactic: rw [Set.preimage_iterate_eq]
state_before: α : Type u
β : Type v
f fa g : α → α
x y : α
fb : β → β
m n✝ k : ℕ
e : Perm α
s : Set α
h : IsFixedPt (Set.preimage f) s
n : ℕ
⊢ IsFixedPt (Set.preimage f^[n]) s
state_after: α : Type u
β : Type v
f fa g : α → α
x y : α
fb : β → β
m n✝ k : ℕ
e : Perm α
s : Set α
h : IsFixedPt (Set.preimage f) s
n : ℕ
⊢ IsFixedPt (Set.preimage f)^[n] s

tactic: exact h.iterate n
state_before: α : Type u
β : Type v
f fa g : α → α
x y : α
fb : β → β
m n✝ k : ℕ
e : Perm α
s : Set α
h : IsFixedPt (Set.preimage f) s
n : ℕ
⊢ IsFixedPt (Set.preimage f)^[n] s
state_after: no goals
Theorem: CategoryTheory.MorphismProperty.IsInvertedBy.op
File: Mathlib/CategoryTheory/MorphismProperty/IsInvertedBy.lean

tactic: haveI := h f.unop hf
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
W : MorphismProperty C
L : C ⥤ D
h : W.IsInvertedBy L
X Y : Cᵒᵖ
f : X ⟶ Y
hf : W.op f
⊢ IsIso (L.op.map f)
state_after: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
W : MorphismProperty C
L : C ⥤ D
h : W.IsInvertedBy L
X Y : Cᵒᵖ
f : X ⟶ Y
hf : W.op f
this : IsIso (L.map f.unop)
⊢ IsIso (L.op.map f)

tactic: dsimp
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
W : MorphismProperty C
L : C ⥤ D
h : W.IsInvertedBy L
X Y : Cᵒᵖ
f : X ⟶ Y
hf : W.op f
this : IsIso (L.map f.unop)
⊢ IsIso (L.op.map f)
state_after: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
W : MorphismProperty C
L : C ⥤ D
h : W.IsInvertedBy L
X Y : Cᵒᵖ
f : X ⟶ Y
hf : W.op f
this : IsIso (L.map f.unop)
⊢ IsIso (L.map f.unop).op

tactic: infer_instance
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
W : MorphismProperty C
L : C ⥤ D
h : W.IsInvertedBy L
X Y : Cᵒᵖ
f : X ⟶ Y
hf : W.op f
this : IsIso (L.map f.unop)
⊢ IsIso (L.map f.unop).op
state_after: no goals
Theorem: Set.pair_diff_left
File: Mathlib/Data/Set/Basic.lean

tactic: rw [insert_diff_of_mem _ (mem_singleton a), diff_singleton_eq_self (by simpa)]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
hne : a ≠ b
⊢ {a, b} \ {a} = {b}
state_after: no goals

tactic: simpa
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
hne : a ≠ b
⊢ a ∉ {b}
state_after: no goals
Theorem: MvPowerSeries.coeff_monomial_ne
File: Mathlib/RingTheory/MvPowerSeries/Basic.lean

tactic: classical
rw [monomial_def]
exact LinearMap.stdBasis_ne R (fun _ ↦ R) _ _ h a
state_before: σ : Type u_1
R : Type u_2
inst✝ : Semiring R
m n : σ →₀ ℕ
h : m ≠ n
a : R
⊢ (coeff R m) ((monomial R n) a) = 0
state_after: no goals

tactic: rw [monomial_def]
state_before: σ : Type u_1
R : Type u_2
inst✝ : Semiring R
m n : σ →₀ ℕ
h : m ≠ n
a : R
⊢ (coeff R m) ((monomial R n) a) = 0
state_after: σ : Type u_1
R : Type u_2
inst✝ : Semiring R
m n : σ →₀ ℕ
h : m ≠ n
a : R
⊢ (coeff R m) ((LinearMap.stdBasis R (fun x => R) n) a) = 0

tactic: exact LinearMap.stdBasis_ne R (fun _ ↦ R) _ _ h a
state_before: σ : Type u_1
R : Type u_2
inst✝ : Semiring R
m n : σ →₀ ℕ
h : m ≠ n
a : R
⊢ (coeff R m) ((LinearMap.stdBasis R (fun x => R) n) a) = 0
state_after: no goals
Theorem: CategoryTheory.Iso.hom_inv_id_triangle_hom₁
File: Mathlib/CategoryTheory/Triangulated/Basic.lean

tactic: rw [← comp_hom₁, e.hom_inv_id, id_hom₁]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasShift C ℤ
T₁ T₂ T₃ A B : Triangle C
e : A ≅ B
⊢ e.hom.hom₁ ≫ e.inv.hom₁ = 𝟙 A.obj₁
state_after: no goals
Theorem: MonoidAlgebra.support_single_mul_eq_image
File: Mathlib/Algebra/MonoidAlgebra/Support.lean

tactic: refine subset_antisymm (support_single_mul_subset f _ _) fun y hy => ?_
state_before: k : Type u₁
G : Type u₂
inst✝² : Semiring k
inst✝¹ : DecidableEq G
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
hr : ∀ (y : k), r * y = 0 ↔ y = 0
x : G
lx : IsLeftRegular x
⊢ (single x r * f).support = image (fun x_1 => x * x_1) f.support
state_after: k : Type u₁
G : Type u₂
inst✝² : Semiring k
inst✝¹ : DecidableEq G
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
hr : ∀ (y : k), r * y = 0 ↔ y = 0
x : G
lx : IsLeftRegular x
y : G
hy : y ∈ image (fun x_1 => x * x_1) f.support
⊢ y ∈ (single x r * f).support

tactic: obtain ⟨y, yf, rfl⟩ : ∃ a : G, a ∈ f.support ∧ x * a = y := by
  simpa only [Finset.mem_image, exists_prop] using hy
state_before: k : Type u₁
G : Type u₂
inst✝² : Semiring k
inst✝¹ : DecidableEq G
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
hr : ∀ (y : k), r * y = 0 ↔ y = 0
x : G
lx : IsLeftRegular x
y : G
hy : y ∈ image (fun x_1 => x * x_1) f.support
⊢ y ∈ (single x r * f).support
state_after: case intro.intro
k : Type u₁
G : Type u₂
inst✝² : Semiring k
inst✝¹ : DecidableEq G
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
hr : ∀ (y : k), r * y = 0 ↔ y = 0
x : G
lx : IsLeftRegular x
y : G
yf : y ∈ f.support
hy : x * y ∈ image (fun x_1 => x * x_1) f.support
⊢ x * y ∈ (single x r * f).support

tactic: simp only [mul_apply, mem_support_iff.mp yf, hr, mem_support_iff, sum_single_index,
  Finsupp.sum_ite_eq', Ne, not_false_iff, if_true, zero_mul, ite_self, sum_zero, lx.eq_iff]
state_before: case intro.intro
k : Type u₁
G : Type u₂
inst✝² : Semiring k
inst✝¹ : DecidableEq G
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
hr : ∀ (y : k), r * y = 0 ↔ y = 0
x : G
lx : IsLeftRegular x
y : G
yf : y ∈ f.support
hy : x * y ∈ image (fun x_1 => x * x_1) f.support
⊢ x * y ∈ (single x r * f).support
state_after: no goals

tactic: simpa only [Finset.mem_image, exists_prop] using hy
state_before: k : Type u₁
G : Type u₂
inst✝² : Semiring k
inst✝¹ : DecidableEq G
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
hr : ∀ (y : k), r * y = 0 ↔ y = 0
x : G
lx : IsLeftRegular x
y : G
hy : y ∈ image (fun x_1 => x * x_1) f.support
⊢ ∃ a ∈ f.support, x * a = y
state_after: no goals
Theorem: Cardinal.aleph'_pos
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: rwa [← aleph'_zero, aleph'_lt]
state_before: o : Ordinal.{u_1}
ho : 0 < o
⊢ 0 < aleph' o
state_after: no goals
Theorem: Set.Icc.addNSMul_eq_right
File: Mathlib/Topology/UnitInterval.lean

tactic: obtain ⟨m, hm⟩ := Archimedean.arch (b - a) hδ
state_before: α : Type u_1
inst✝¹ : LinearOrderedAddCommGroup α
a b c d : α
h : a ≤ b
δ : α
inst✝ : Archimedean α
hδ : 0 < δ
⊢ ∃ m, ∀ n ≥ m, ↑(addNSMul h δ n) = b
state_after: case intro
α : Type u_1
inst✝¹ : LinearOrderedAddCommGroup α
a b c d : α
h : a ≤ b
δ : α
inst✝ : Archimedean α
hδ : 0 < δ
m : ℕ
hm : b - a ≤ m • δ
⊢ ∃ m, ∀ n ≥ m, ↑(addNSMul h δ n) = b

tactic: refine ⟨m, fun n hn ↦ ?_⟩
state_before: case intro
α : Type u_1
inst✝¹ : LinearOrderedAddCommGroup α
a b c d : α
h : a ≤ b
δ : α
inst✝ : Archimedean α
hδ : 0 < δ
m : ℕ
hm : b - a ≤ m • δ
⊢ ∃ m, ∀ n ≥ m, ↑(addNSMul h δ n) = b
state_after: case intro
α : Type u_1
inst✝¹ : LinearOrderedAddCommGroup α
a b c d : α
h : a ≤ b
δ : α
inst✝ : Archimedean α
hδ : 0 < δ
m : ℕ
hm : b - a ≤ m • δ
n : ℕ
hn : n ≥ m
⊢ ↑(addNSMul h δ n) = b

tactic: rw [addNSMul, coe_projIcc, add_comm, min_eq_left_iff.mpr, max_eq_right h]
state_before: case intro
α : Type u_1
inst✝¹ : LinearOrderedAddCommGroup α
a b c d : α
h : a ≤ b
δ : α
inst✝ : Archimedean α
hδ : 0 < δ
m : ℕ
hm : b - a ≤ m • δ
n : ℕ
hn : n ≥ m
⊢ ↑(addNSMul h δ n) = b
state_after: case intro
α : Type u_1
inst✝¹ : LinearOrderedAddCommGroup α
a b c d : α
h : a ≤ b
δ : α
inst✝ : Archimedean α
hδ : 0 < δ
m : ℕ
hm : b - a ≤ m • δ
n : ℕ
hn : n ≥ m
⊢ b ≤ n • δ + a

tactic: exact sub_le_iff_le_add.mp (hm.trans <| nsmul_le_nsmul_left hδ.le hn)
state_before: case intro
α : Type u_1
inst✝¹ : LinearOrderedAddCommGroup α
a b c d : α
h : a ≤ b
δ : α
inst✝ : Archimedean α
hδ : 0 < δ
m : ℕ
hm : b - a ≤ m • δ
n : ℕ
hn : n ≥ m
⊢ b ≤ n • δ + a
state_after: no goals
Theorem: Orientation.inner_rightAngleRotation_swap'
File: Mathlib/Analysis/InnerProductSpace/TwoDim.lean

tactic: simp [o.inner_rightAngleRotation_swap x y]
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x y : E
⊢ ⟪o.rightAngleRotation x, y⟫_ℝ = -⟪x, o.rightAngleRotation y⟫_ℝ
state_after: no goals
Theorem: Multiset.disjoint_finset_sum_left
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

tactic: convert @disjoint_sum_left _ a (map f i.val)
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β✝ : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a✝ : α
f✝ g : α → β✝
β : Type u_6
i : Finset β
f : β → Multiset α
a : Multiset α
⊢ (i.sum f).Disjoint a ↔ ∀ b ∈ i, (f b).Disjoint a
state_after: case h.e'_2.a
ι : Type u_1
κ : Type u_2
α : Type u_3
β✝ : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a✝ : α
f✝ g : α → β✝
β : Type u_6
i : Finset β
f : β → Multiset α
a : Multiset α
⊢ (∀ b ∈ i, (f b).Disjoint a) ↔ ∀ b ∈ map f i.val, b.Disjoint a

tactic: simp [and_congr_left_iff, iff_self_iff]
state_before: case h.e'_2.a
ι : Type u_1
κ : Type u_2
α : Type u_3
β✝ : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a✝ : α
f✝ g : α → β✝
β : Type u_6
i : Finset β
f : β → Multiset α
a : Multiset α
⊢ (∀ b ∈ i, (f b).Disjoint a) ↔ ∀ b ∈ map f i.val, b.Disjoint a
state_after: no goals
Theorem: List.map₂Left_eq_map₂Left'
File: Mathlib/Data/List/Basic.lean

tactic: simp
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → Option β → γ
as : List α
x✝ : List β
⊢ map₂Left f [] x✝ = (map₂Left' f [] x✝).1
state_after: no goals

tactic: simp
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → Option β → γ
as✝ : List α
a : α
as : List α
⊢ map₂Left f (a :: as) [] = (map₂Left' f (a :: as) []).1
state_after: no goals

tactic: simp [map₂Left_eq_map₂Left']
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → Option β → γ
as✝ : List α
a : α
as : List α
b : β
bs : List β
⊢ map₂Left f (a :: as) (b :: bs) = (map₂Left' f (a :: as) (b :: bs)).1
state_after: no goals
Theorem: MeasureTheory.integrableAtFilter_top
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

tactic: refine ⟨fun h ↦ ?_, fun h ↦ h.integrableAtFilter ⊤⟩
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
l l' : Filter α
⊢ IntegrableAtFilter f ⊤ μ ↔ Integrable f μ
state_after: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
l l' : Filter α
h : IntegrableAtFilter f ⊤ μ
⊢ Integrable f μ

tactic: obtain ⟨s, hsf, hs⟩ := h
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
l l' : Filter α
h : IntegrableAtFilter f ⊤ μ
⊢ Integrable f μ
state_after: case intro.intro
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s✝ t : Set α
μ ν : Measure α
l l' : Filter α
s : Set α
hsf : s ∈ ⊤
hs : IntegrableOn f s μ
⊢ Integrable f μ

tactic: exact (integrableOn_iff_integrable_of_support_subset fun _ _ ↦ hsf _).mp hs
state_before: case intro.intro
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s✝ t : Set α
μ ν : Measure α
l l' : Filter α
s : Set α
hsf : s ∈ ⊤
hs : IntegrableOn f s μ
⊢ Integrable f μ
state_after: no goals
Theorem: PiNat.cylinder_eq_res
File: Mathlib/Topology/MetricSpace/PiNat.lean

tactic: ext y
state_before: E : ℕ → Type u_1
α : Type u_2
x : ℕ → α
n : ℕ
⊢ cylinder x n = {y | res y n = res x n}
state_after: case h
E : ℕ → Type u_1
α : Type u_2
x : ℕ → α
n : ℕ
y : ℕ → α
⊢ y ∈ cylinder x n ↔ y ∈ {y | res y n = res x n}

tactic: dsimp [cylinder]
state_before: case h
E : ℕ → Type u_1
α : Type u_2
x : ℕ → α
n : ℕ
y : ℕ → α
⊢ y ∈ cylinder x n ↔ y ∈ {y | res y n = res x n}
state_after: case h
E : ℕ → Type u_1
α : Type u_2
x : ℕ → α
n : ℕ
y : ℕ → α
⊢ (∀ i < n, y i = x i) ↔ res y n = res x n

tactic: rw [res_eq_res]
state_before: case h
E : ℕ → Type u_1
α : Type u_2
x : ℕ → α
n : ℕ
y : ℕ → α
⊢ (∀ i < n, y i = x i) ↔ res y n = res x n
state_after: no goals
Theorem: Module.End.IsSemisimple.of_mem_adjoin_singleton
File: Mathlib/LinearAlgebra/Semisimple.lean

tactic: rw [Algebra.adjoin_singleton_eq_range_aeval] at ha
state_before: R : Type u_1
M : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
K : Type u_3
inst✝² : Field K
inst✝¹ : Module K M
f g : End K M
inst✝ : FiniteDimensional K M
hf : f.IsSemisimple
a : End K M
ha : a ∈ Algebra.adjoin K {f}
⊢ a.IsSemisimple
state_after: R : Type u_1
M : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
K : Type u_3
inst✝² : Field K
inst✝¹ : Module K M
f g : End K M
inst✝ : FiniteDimensional K M
hf : f.IsSemisimple
a : End K M
ha : a ∈ (aeval f).range
⊢ a.IsSemisimple

tactic: obtain ⟨p, rfl⟩ := ha
state_before: R : Type u_1
M : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
K : Type u_3
inst✝² : Field K
inst✝¹ : Module K M
f g : End K M
inst✝ : FiniteDimensional K M
hf : f.IsSemisimple
a : End K M
ha : a ∈ (aeval f).range
⊢ a.IsSemisimple
state_after: case intro
R : Type u_1
M : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
K : Type u_3
inst✝² : Field K
inst✝¹ : Module K M
f g : End K M
inst✝ : FiniteDimensional K M
hf : f.IsSemisimple
p : K[X]
⊢ ((aeval f).toRingHom p).IsSemisimple

tactic: exact .aeval hf _
state_before: case intro
R : Type u_1
M : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
K : Type u_3
inst✝² : Field K
inst✝¹ : Module K M
f g : End K M
inst✝ : FiniteDimensional K M
hf : f.IsSemisimple
p : K[X]
⊢ ((aeval f).toRingHom p).IsSemisimple
state_after: no goals
Theorem: WeierstrassCurve.Jacobian.addY_of_X_eq
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

tactic: rw [addU, ← neg_div, div_pow, ← addY_of_X_eq' hP hQ hx,
  mul_div_cancel_right₀ _ <| pow_ne_zero 3 <| mul_ne_zero hPz hQz]
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : Fin 3 → F
hP : W.Equation P
hQ : W.Equation Q
hPz : P z ≠ 0
hQz : Q z ≠ 0
hx : P x * Q z ^ 2 = Q x * P z ^ 2
⊢ W.addY P Q = addU P Q ^ 3
state_after: no goals
Theorem: Int.cast_add
File: Mathlib/Data/Int/Cast/Basic.lean

tactic: simp [-Int.natCast_add, ← Int.ofNat_add]
state_before: R : Type u
inst✝ : AddGroupWithOne R
m n : ℕ
⊢ ↑(↑m + ↑n) = ↑↑m + ↑↑n
state_after: no goals

tactic: erw [cast_subNatNat, cast_natCast, cast_negSucc, sub_eq_add_neg]
state_before: R : Type u
inst✝ : AddGroupWithOne R
m n : ℕ
⊢ ↑(↑m + -[n+1]) = ↑↑m + ↑-[n+1]
state_after: no goals

tactic: erw [cast_subNatNat, cast_natCast, cast_negSucc, sub_eq_iff_eq_add, add_assoc,
  eq_neg_add_iff_add_eq, ← Nat.cast_add, ← Nat.cast_add, Nat.add_comm]
state_before: R : Type u
inst✝ : AddGroupWithOne R
m n : ℕ
⊢ ↑(-[m+1] + ↑n) = ↑-[m+1] + ↑↑n
state_after: no goals

tactic: rw [cast_negSucc, cast_negSucc, cast_negSucc, ← neg_add_rev, ← Nat.cast_add,
  Nat.add_right_comm m n 1, Nat.add_assoc, Nat.add_comm]
state_before: R : Type u
inst✝ : AddGroupWithOne R
m n : ℕ
⊢ ↑-[m + n + 1+1] = ↑-[m+1] + ↑-[n+1]
state_after: no goals
Theorem: Nat.lt_one_iff
File: Mathlib/Data/Nat/Defs.lean

tactic: rw [le_zero_eq]
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
⊢ n ≤ 0 ↔ n = 0
state_after: no goals
Theorem: Polynomial.root_mul_left_of_isRoot
File: Mathlib/Algebra/Polynomial/Eval.lean

tactic: rw [IsRoot, eval_mul, IsRoot.def.1 H, mul_zero]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : CommSemiring R
p✝ q✝ : R[X]
x : R
inst✝ : CommSemiring S
f : R →+* S
p q : R[X]
H : q.IsRoot a
⊢ (p * q).IsRoot a
state_after: no goals
Theorem: Int.cast_bit1
File: Mathlib/Data/Int/Cast/Basic.lean

tactic: rw [bit1, Int.cast_add, Int.cast_one, cast_bit0]
state_before: R : Type u
inst✝ : AddGroupWithOne R
n : ℤ
⊢ ↑(bit1 n) = bit1 ↑n
state_after: R : Type u
inst✝ : AddGroupWithOne R
n : ℤ
⊢ bit0 ↑n + 1 = bit1 ↑n

tactic: rfl
state_before: R : Type u
inst✝ : AddGroupWithOne R
n : ℤ
⊢ bit0 ↑n + 1 = bit1 ↑n
state_after: no goals
Theorem: CategoryTheory.ShiftMkCore.shiftFunctorZero_eq
File: Mathlib/CategoryTheory/Shift/Basic.lean

tactic: letI := hasShiftMk C A h
state_before: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
h : ShiftMkCore C A
⊢ shiftFunctorZero C A = h.zero
state_after: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
h : ShiftMkCore C A
this : HasShift C A := hasShiftMk C A h
⊢ shiftFunctorZero C A = h.zero

tactic: dsimp [shiftFunctorZero]
state_before: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
h : ShiftMkCore C A
this : HasShift C A := hasShiftMk C A h
⊢ shiftFunctorZero C A = h.zero
state_after: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
h : ShiftMkCore C A
this : HasShift C A := hasShiftMk C A h
⊢ (shiftMonoidalFunctor C A).εIso.symm = h.zero

tactic: change (shiftFunctorZero C A).symm.symm = h.zero.symm.symm
state_before: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
h : ShiftMkCore C A
this : HasShift C A := hasShiftMk C A h
⊢ (shiftMonoidalFunctor C A).εIso.symm = h.zero
state_after: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
h : ShiftMkCore C A
this : HasShift C A := hasShiftMk C A h
⊢ (shiftFunctorZero C A).symm.symm = h.zero.symm.symm

tactic: congr 1
state_before: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
h : ShiftMkCore C A
this : HasShift C A := hasShiftMk C A h
⊢ (shiftFunctorZero C A).symm.symm = h.zero.symm.symm
state_after: case e_I
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
h : ShiftMkCore C A
this : HasShift C A := hasShiftMk C A h
⊢ (shiftFunctorZero C A).symm = h.zero.symm

tactic: ext
state_before: case e_I
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
h : ShiftMkCore C A
this : HasShift C A := hasShiftMk C A h
⊢ (shiftFunctorZero C A).symm = h.zero.symm
state_after: case e_I.w.w.h
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
h : ShiftMkCore C A
this : HasShift C A := hasShiftMk C A h
x✝ : C
⊢ (shiftFunctorZero C A).symm.hom.app x✝ = h.zero.symm.hom.app x✝

tactic: rfl
state_before: case e_I.w.w.h
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
h : ShiftMkCore C A
this : HasShift C A := hasShiftMk C A h
x✝ : C
⊢ (shiftFunctorZero C A).symm.hom.app x✝ = h.zero.symm.hom.app x✝
state_after: no goals
Theorem: CategoryTheory.CommSq.op
File: Mathlib/CategoryTheory/CommSq.lean

tactic: simp only [← op_comp, p.w]
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
W X Y Z : C
f : W ⟶ X
g : W ⟶ Y
h : X ⟶ Z
i : Y ⟶ Z
p : CommSq f g h i
⊢ i.op ≫ g.op = h.op ≫ f.op
state_after: no goals
Theorem: Metric.subset_compl_thickening_compl_thickening_self
File: Mathlib/Topology/MetricSpace/Thickening.lean

tactic: intro x x_in_E
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ : ℝ
s : Set α
x : α
δ : ℝ
E : Set α
⊢ E ⊆ (thickening δ (thickening δ E)ᶜ)ᶜ
state_after: ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ : ℝ
s : Set α
x✝ : α
δ : ℝ
E : Set α
x : α
x_in_E : x ∈ E
⊢ x ∈ (thickening δ (thickening δ E)ᶜ)ᶜ

tactic: simp only [thickening, mem_compl_iff, mem_setOf_eq, not_lt]
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ : ℝ
s : Set α
x✝ : α
δ : ℝ
E : Set α
x : α
x_in_E : x ∈ E
⊢ x ∈ (thickening δ (thickening δ E)ᶜ)ᶜ
state_after: ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ : ℝ
s : Set α
x✝ : α
δ : ℝ
E : Set α
x : α
x_in_E : x ∈ E
⊢ ENNReal.ofReal δ ≤ infEdist x {x | infEdist x E < ENNReal.ofReal δ}ᶜ

tactic: apply EMetric.le_infEdist.mpr fun y hy ↦ ?_
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ : ℝ
s : Set α
x✝ : α
δ : ℝ
E : Set α
x : α
x_in_E : x ∈ E
⊢ ENNReal.ofReal δ ≤ infEdist x {x | infEdist x E < ENNReal.ofReal δ}ᶜ
state_after: ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ : ℝ
s : Set α
x✝ : α
δ : ℝ
E : Set α
x : α
x_in_E : x ∈ E
y : α
hy : y ∈ {x | infEdist x E < ENNReal.ofReal δ}ᶜ
⊢ ENNReal.ofReal δ ≤ edist x y

tactic: simp only [mem_compl_iff, mem_setOf_eq, not_lt] at hy
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ : ℝ
s : Set α
x✝ : α
δ : ℝ
E : Set α
x : α
x_in_E : x ∈ E
y : α
hy : y ∈ {x | infEdist x E < ENNReal.ofReal δ}ᶜ
⊢ ENNReal.ofReal δ ≤ edist x y
state_after: ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ : ℝ
s : Set α
x✝ : α
δ : ℝ
E : Set α
x : α
x_in_E : x ∈ E
y : α
hy : ENNReal.ofReal δ ≤ infEdist y E
⊢ ENNReal.ofReal δ ≤ edist x y

tactic: simpa only [edist_comm] using le_trans hy <| EMetric.infEdist_le_edist_of_mem x_in_E
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ : ℝ
s : Set α
x✝ : α
δ : ℝ
E : Set α
x : α
x_in_E : x ∈ E
y : α
hy : ENNReal.ofReal δ ≤ infEdist y E
⊢ ENNReal.ofReal δ ≤ edist x y
state_after: no goals
Theorem: Set.eq_of_mem_uIcc_of_mem_uIcc'
File: Mathlib/Order/Interval/Set/UnorderedInterval.lean

tactic: simpa only [uIcc_comm a] using eq_of_mem_uIcc_of_mem_uIcc
state_before: α : Type u_1
β : Type u_2
inst✝ : DistribLattice α
a a₁ a₂ b b₁ b₂ c x : α
⊢ b ∈ [[a, c]] → c ∈ [[a, b]] → b = c
state_after: no goals
Theorem: Orientation.inner_rev_eq_zero_of_oangle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean

tactic: rw [real_inner_comm, o.inner_eq_zero_of_oangle_eq_pi_div_two h]
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : o.oangle x y = ↑(π / 2)
⊢ ⟪y, x⟫_ℝ = 0
state_after: no goals
Theorem: Pell.strictMono_x
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: have : xn a1 m ≤ xn a1 n :=
  Or.elim (lt_or_eq_of_le <| Nat.le_of_succ_le_succ h) (fun hl => le_of_lt <| strictMono_x hl)
    fun e => by rw [e]
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
h : m < n + 1
⊢ xn a1 m < xn a1 (n + 1)
state_after: a : ℕ
a1 : 1 < a
m n : ℕ
h : m < n + 1
this : xn a1 m ≤ xn a1 n
⊢ xn a1 m < xn a1 (n + 1)

tactic: simp
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
h : m < n + 1
this : xn a1 m ≤ xn a1 n
⊢ xn a1 m < xn a1 (n + 1)
state_after: a : ℕ
a1 : 1 < a
m n : ℕ
h : m < n + 1
this : xn a1 m ≤ xn a1 n
⊢ xn a1 m < xn a1 n * a + Pell.d a1 * yn a1 n

tactic: refine lt_of_lt_of_le (lt_of_le_of_lt this ?_) (Nat.le_add_right _ _)
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
h : m < n + 1
this : xn a1 m ≤ xn a1 n
⊢ xn a1 m < xn a1 n * a + Pell.d a1 * yn a1 n
state_after: a : ℕ
a1 : 1 < a
m n : ℕ
h : m < n + 1
this : xn a1 m ≤ xn a1 n
⊢ xn a1 n < xn a1 n * a

tactic: have t := Nat.mul_lt_mul_of_pos_left a1 (x_pos a1 n)
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
h : m < n + 1
this : xn a1 m ≤ xn a1 n
⊢ xn a1 n < xn a1 n * a
state_after: a : ℕ
a1 : 1 < a
m n : ℕ
h : m < n + 1
this : xn a1 m ≤ xn a1 n
t : xn a1 n * 1 < xn a1 n * a
⊢ xn a1 n < xn a1 n * a

tactic: rwa [mul_one] at t
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
h : m < n + 1
this : xn a1 m ≤ xn a1 n
t : xn a1 n * 1 < xn a1 n * a
⊢ xn a1 n < xn a1 n * a
state_after: no goals

tactic: rw [e]
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
h : m < n + 1
e : m = n
⊢ xn a1 m ≤ xn a1 n
state_after: no goals