1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: EuclideanGeometry.angle_add_angle_eq_pi_of_angle_eq_pi
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.lean

tactic: unfold angle at h
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p p₀ p₁ p₂ p1 p2 p3 p4 : P
h : ∠ p2 p3 p4 = π
⊢ ∠ p1 p3 p2 + ∠ p1 p3 p4 = π
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p p₀ p₁ p₂ p1 p2 p3 p4 : P
h : InnerProductGeometry.angle (p2 -ᵥ p3) (p4 -ᵥ p3) = π
⊢ ∠ p1 p3 p2 + ∠ p1 p3 p4 = π

tactic: rw [angle_comm p1 p3 p2, angle_comm p1 p3 p4]
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p p₀ p₁ p₂ p1 p2 p3 p4 : P
h : InnerProductGeometry.angle (p2 -ᵥ p3) (p4 -ᵥ p3) = π
⊢ ∠ p1 p3 p2 + ∠ p1 p3 p4 = π
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p p₀ p₁ p₂ p1 p2 p3 p4 : P
h : InnerProductGeometry.angle (p2 -ᵥ p3) (p4 -ᵥ p3) = π
⊢ ∠ p2 p3 p1 + ∠ p4 p3 p1 = π

tactic: unfold angle
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p p₀ p₁ p₂ p1 p2 p3 p4 : P
h : InnerProductGeometry.angle (p2 -ᵥ p3) (p4 -ᵥ p3) = π
⊢ ∠ p2 p3 p1 + ∠ p4 p3 p1 = π
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p p₀ p₁ p₂ p1 p2 p3 p4 : P
h : InnerProductGeometry.angle (p2 -ᵥ p3) (p4 -ᵥ p3) = π
⊢ InnerProductGeometry.angle (p2 -ᵥ p3) (p1 -ᵥ p3) + InnerProductGeometry.angle (p4 -ᵥ p3) (p1 -ᵥ p3) = π

tactic: exact angle_add_angle_eq_pi_of_angle_eq_pi _ h
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p p₀ p₁ p₂ p1 p2 p3 p4 : P
h : InnerProductGeometry.angle (p2 -ᵥ p3) (p4 -ᵥ p3) = π
⊢ InnerProductGeometry.angle (p2 -ᵥ p3) (p1 -ᵥ p3) + InnerProductGeometry.angle (p4 -ᵥ p3) (p1 -ᵥ p3) = π
state_after: no goals
Theorem: Matroid.uniqueBaseOn_empty
File: Mathlib/Data/Matroid/Constructions.lean

tactic: rw [← dual_inj, uniqueBaseOn_dual_eq, diff_empty, uniqueBaseOn_self, loopyOn_dual_eq]
state_before: α : Type u_1
M : Matroid α
E B I✝ X R J I : Set α
⊢ uniqueBaseOn ∅ I = loopyOn I
state_after: no goals
Theorem: Matrix.vecMul_mulVec
File: Mathlib/Data/Matrix/Basic.lean

tactic: rw [← vecMul_vecMul, vecMul_transpose]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : NonUnitalCommSemiring α
inst✝¹ : Fintype m
inst✝ : Fintype n
A : Matrix m n α
B : Matrix m o α
x : n → α
⊢ (A *ᵥ x) ᵥ* B = x ᵥ* (Aᵀ * B)
state_after: no goals
Theorem: Set.encard_lt_encard_iff_encard_diff_lt_encard_diff
File: Mathlib/Data/Set/Card.lean

tactic: rw [← encard_diff_add_encard_inter s t, ← encard_diff_add_encard_inter t s, inter_comm t s,
  WithTop.add_lt_add_iff_right h.encard_lt_top.ne]
state_before: α : Type u_1
β : Type u_2
s t : Set α
h : (s ∩ t).Finite
⊢ s.encard < t.encard ↔ (s \ t).encard < (t \ s).encard
state_after: no goals
Theorem: summable_of_summable_hasFDerivAt
File: Mathlib/Analysis/Calculus/SmoothSeries.lean

tactic: let _ : NormedSpace ℝ E := NormedSpace.restrictScalars ℝ 𝕜 _
state_before: α : Type u_1
β : Type u_2
𝕜 : Type u_3
E : Type u_4
F : Type u_5
inst✝⁵ : RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : CompleteSpace F
u : α → ℝ
inst✝ : NormedSpace 𝕜 F
f : α → E → F
f' : α → E → E →L[𝕜] F
g g' : α → 𝕜 → F
v : ℕ → α → ℝ
s : Set E
t : Set 𝕜
x₀ x✝ : E
y₀ y : 𝕜
N : ℕ∞
hu : Summable u
hf : ∀ (n : α) (x : E), HasFDerivAt (f n) (f' n x) x
hf' : ∀ (n : α) (x : E), ‖f' n x‖ ≤ u n
hf0 : Summable fun n => f n x₀
x : E
⊢ Summable fun n => f n x
state_after: α : Type u_1
β : Type u_2
𝕜 : Type u_3
E : Type u_4
F : Type u_5
inst✝⁵ : RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : CompleteSpace F
u : α → ℝ
inst✝ : NormedSpace 𝕜 F
f : α → E → F
f' : α → E → E →L[𝕜] F
g g' : α → 𝕜 → F
v : ℕ → α → ℝ
s : Set E
t : Set 𝕜
x₀ x✝¹ : E
y₀ y : 𝕜
N : ℕ∞
hu : Summable u
hf : ∀ (n : α) (x : E), HasFDerivAt (f n) (f' n x) x
hf' : ∀ (n : α) (x : E), ‖f' n x‖ ≤ u n
hf0 : Summable fun n => f n x₀
x : E
x✝ : NormedSpace ℝ E := NormedSpace.restrictScalars ℝ 𝕜 E
⊢ Summable fun n => f n x

tactic: exact summable_of_summable_hasFDerivAt_of_isPreconnected hu isOpen_univ isPreconnected_univ
  (fun n x _ => hf n x) (fun n x _ => hf' n x) (mem_univ _) hf0 (mem_univ _)
state_before: α : Type u_1
β : Type u_2
𝕜 : Type u_3
E : Type u_4
F : Type u_5
inst✝⁵ : RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : CompleteSpace F
u : α → ℝ
inst✝ : NormedSpace 𝕜 F
f : α → E → F
f' : α → E → E →L[𝕜] F
g g' : α → 𝕜 → F
v : ℕ → α → ℝ
s : Set E
t : Set 𝕜
x₀ x✝¹ : E
y₀ y : 𝕜
N : ℕ∞
hu : Summable u
hf : ∀ (n : α) (x : E), HasFDerivAt (f n) (f' n x) x
hf' : ∀ (n : α) (x : E), ‖f' n x‖ ≤ u n
hf0 : Summable fun n => f n x₀
x : E
x✝ : NormedSpace ℝ E := NormedSpace.restrictScalars ℝ 𝕜 E
⊢ Summable fun n => f n x
state_after: no goals
Theorem: Complex.sin_two_mul
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [two_mul, sin_add, two_mul, add_mul, mul_comm]
state_before: x y : ℂ
⊢ sin (2 * x) = 2 * sin x * cos x
state_after: no goals
Theorem: Finset.weightedVSubOfPoint_indicator_subset
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: rw [weightedVSubOfPoint_apply, weightedVSubOfPoint_apply]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_4
s : Finset ι
ι₂ : Type u_5
s₂✝ : Finset ι₂
w : ι → k
p : ι → P
b : P
s₁ s₂ : Finset ι
h : s₁ ⊆ s₂
⊢ (s₁.weightedVSubOfPoint p b) w = (s₂.weightedVSubOfPoint p b) ((↑s₁).indicator w)
state_after: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_4
s : Finset ι
ι₂ : Type u_5
s₂✝ : Finset ι₂
w : ι → k
p : ι → P
b : P
s₁ s₂ : Finset ι
h : s₁ ⊆ s₂
⊢ ∑ i ∈ s₁, w i • (p i -ᵥ b) = ∑ i ∈ s₂, (↑s₁).indicator w i • (p i -ᵥ b)

tactic: exact Eq.symm <|
  sum_indicator_subset_of_eq_zero w (fun i wi => wi • (p i -ᵥ b : V)) h fun i => zero_smul k _
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_4
s : Finset ι
ι₂ : Type u_5
s₂✝ : Finset ι₂
w : ι → k
p : ι → P
b : P
s₁ s₂ : Finset ι
h : s₁ ⊆ s₂
⊢ ∑ i ∈ s₁, w i • (p i -ᵥ b) = ∑ i ∈ s₂, (↑s₁).indicator w i • (p i -ᵥ b)
state_after: no goals
Theorem: Complex.arg_eq_zero_iff
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: refine ⟨fun h => ?_, ?_⟩
state_before: a x z✝ z : ℂ
⊢ z.arg = 0 ↔ 0 ≤ z.re ∧ z.im = 0
state_after: case refine_1
a x z✝ z : ℂ
h : z.arg = 0
⊢ 0 ≤ z.re ∧ z.im = 0

case refine_2
a x z✝ z : ℂ
⊢ 0 ≤ z.re ∧ z.im = 0 → z.arg = 0

tactic: rw [← abs_mul_cos_add_sin_mul_I z, h]
state_before: case refine_1
a x z✝ z : ℂ
h : z.arg = 0
⊢ 0 ≤ z.re ∧ z.im = 0
state_after: case refine_1
a x z✝ z : ℂ
h : z.arg = 0
⊢ 0 ≤ (↑(abs z) * (cos ↑0 + sin ↑0 * I)).re ∧ (↑(abs z) * (cos ↑0 + sin ↑0 * I)).im = 0

tactic: simp [abs.nonneg]
state_before: case refine_1
a x z✝ z : ℂ
h : z.arg = 0
⊢ 0 ≤ (↑(abs z) * (cos ↑0 + sin ↑0 * I)).re ∧ (↑(abs z) * (cos ↑0 + sin ↑0 * I)).im = 0
state_after: no goals

tactic: cases' z with x y
state_before: case refine_2
a x z✝ z : ℂ
⊢ 0 ≤ z.re ∧ z.im = 0 → z.arg = 0
state_after: case refine_2.mk
a x✝ z : ℂ
x y : ℝ
⊢ 0 ≤ { re := x, im := y }.re ∧ { re := x, im := y }.im = 0 → { re := x, im := y }.arg = 0

tactic: rintro ⟨h, rfl : y = 0⟩
state_before: case refine_2.mk
a x✝ z : ℂ
x y : ℝ
⊢ 0 ≤ { re := x, im := y }.re ∧ { re := x, im := y }.im = 0 → { re := x, im := y }.arg = 0
state_after: case refine_2.mk.intro
a x✝ z : ℂ
x : ℝ
h : 0 ≤ { re := x, im := 0 }.re
⊢ { re := x, im := 0 }.arg = 0

tactic: exact arg_ofReal_of_nonneg h
state_before: case refine_2.mk.intro
a x✝ z : ℂ
x : ℝ
h : 0 ≤ { re := x, im := 0 }.re
⊢ { re := x, im := 0 }.arg = 0
state_after: no goals
Theorem: Int.csInf_empty
File: Mathlib/Data/Int/ConditionallyCompleteOrder.lean

tactic: simp
state_before: ⊢ ¬(∅.Nonempty ∧ BddBelow ∅)
state_after: no goals
Theorem: FirstOrder.Language.Equiv.realize_formula
File: Mathlib/ModelTheory/Semantics.lean

tactic: rw [Formula.Realize, Formula.Realize, ← g.realize_boundedFormula φ, iff_eq_eq,
  Unique.eq_default (g ∘ default)]
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n : ℕ
T : L.Theory
g : M ≃[L] N
φ : L.Formula α
v : α → M
⊢ φ.Realize (⇑g ∘ v) ↔ φ.Realize v
state_after: no goals
Theorem: Finset.le_sum_condensed
File: Mathlib/Analysis/PSeries.lean

tactic: convert add_le_add_left (le_sum_condensed' hf n) (f 0)
state_before: M : Type u_1
inst✝ : OrderedAddCommMonoid M
f : ℕ → M
u : ℕ → ℕ
hf : ∀ ⦃m n : ℕ⦄, 0 < m → m ≤ n → f n ≤ f m
n : ℕ
⊢ ∑ k ∈ range (2 ^ n), f k ≤ f 0 + ∑ k ∈ range n, 2 ^ k • f (2 ^ k)
state_after: case h.e'_3
M : Type u_1
inst✝ : OrderedAddCommMonoid M
f : ℕ → M
u : ℕ → ℕ
hf : ∀ ⦃m n : ℕ⦄, 0 < m → m ≤ n → f n ≤ f m
n : ℕ
⊢ ∑ k ∈ range (2 ^ n), f k = f 0 + ∑ k ∈ Ico 1 (2 ^ n), f k

tactic: rw [← sum_range_add_sum_Ico _ n.one_le_two_pow, sum_range_succ, sum_range_zero, zero_add]
state_before: case h.e'_3
M : Type u_1
inst✝ : OrderedAddCommMonoid M
f : ℕ → M
u : ℕ → ℕ
hf : ∀ ⦃m n : ℕ⦄, 0 < m → m ≤ n → f n ≤ f m
n : ℕ
⊢ ∑ k ∈ range (2 ^ n), f k = f 0 + ∑ k ∈ Ico 1 (2 ^ n), f k
state_after: no goals
Theorem: ContractingWith.tendsto_iterate_fixedPoint
File: Mathlib/Topology/MetricSpace/Contracting.lean

tactic: convert tendsto_iterate_efixedPoint hf (edist_ne_top x _)
state_before: α : Type u_1
inst✝² : MetricSpace α
K : ℝ≥0
f : α → α
hf : ContractingWith K f
inst✝¹ : Nonempty α
inst✝ : CompleteSpace α
x : α
⊢ Tendsto (fun n => f^[n] x) atTop (𝓝 (fixedPoint f hf))
state_after: case h.e'_5.h.e'_3
α : Type u_1
inst✝² : MetricSpace α
K : ℝ≥0
f : α → α
hf : ContractingWith K f
inst✝¹ : Nonempty α
inst✝ : CompleteSpace α
x : α
⊢ fixedPoint f hf = efixedPoint f hf x ⋯

tactic: refine (fixedPoint_unique _ ?_).symm
state_before: case h.e'_5.h.e'_3
α : Type u_1
inst✝² : MetricSpace α
K : ℝ≥0
f : α → α
hf : ContractingWith K f
inst✝¹ : Nonempty α
inst✝ : CompleteSpace α
x : α
⊢ fixedPoint f hf = efixedPoint f hf x ⋯
state_after: case h.e'_5.h.e'_3
α : Type u_1
inst✝² : MetricSpace α
K : ℝ≥0
f : α → α
hf : ContractingWith K f
inst✝¹ : Nonempty α
inst✝ : CompleteSpace α
x : α
⊢ IsFixedPt f (efixedPoint f hf x ⋯)

tactic: apply efixedPoint_isFixedPt
state_before: case h.e'_5.h.e'_3
α : Type u_1
inst✝² : MetricSpace α
K : ℝ≥0
f : α → α
hf : ContractingWith K f
inst✝¹ : Nonempty α
inst✝ : CompleteSpace α
x : α
⊢ IsFixedPt f (efixedPoint f hf x ⋯)
state_after: no goals
Theorem: Set.Ioo_inter_Ioc_of_right_lt
File: Mathlib/Order/Interval/Set/Basic.lean

tactic: rw [inter_comm, Ioc_inter_Ioo_of_left_lt h, max_comm]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
a a₁ a₂ b b₁ b₂ c d : α
h : b₂ < b₁
⊢ Ioo a₁ b₁ ∩ Ioc a₂ b₂ = Ioc (max a₁ a₂) b₂
state_after: no goals
Theorem: Set.image_subset_image_iff
File: Mathlib/Data/Set/Image.lean

tactic: refine Iff.symm <| (Iff.intro (image_subset f)) fun h => ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
s t : Set α
f : α → β
hf : Injective f
⊢ f '' s ⊆ f '' t ↔ s ⊆ t
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
s t : Set α
f : α → β
hf : Injective f
h : f '' s ⊆ f '' t
⊢ s ⊆ t

tactic: rw [← preimage_image_eq s hf, ← preimage_image_eq t hf]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
s t : Set α
f : α → β
hf : Injective f
h : f '' s ⊆ f '' t
⊢ s ⊆ t
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
s t : Set α
f : α → β
hf : Injective f
h : f '' s ⊆ f '' t
⊢ f ⁻¹' (f '' s) ⊆ f ⁻¹' (f '' t)

tactic: exact preimage_mono h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
s t : Set α
f : α → β
hf : Injective f
h : f '' s ⊆ f '' t
⊢ f ⁻¹' (f '' s) ⊆ f ⁻¹' (f '' t)
state_after: no goals
Theorem: CategoryTheory.Functor.curry_obj_injective
File: Mathlib/CategoryTheory/Functor/Currying.lean

tactic: rw [← uncurry_obj_curry_obj F₁, ← uncurry_obj_curry_obj F₂, h]
state_before: B : Type u₁
inst✝⁴ : Category.{v₁, u₁} B
C : Type u₂
inst✝³ : Category.{v₂, u₂} C
D : Type u₃
inst✝² : Category.{v₃, u₃} D
E : Type u₄
inst✝¹ : Category.{v₄, u₄} E
H : Type u₅
inst✝ : Category.{v₅, u₅} H
F₁ F₂ : C × D ⥤ E
h : curry.obj F₁ = curry.obj F₂
⊢ F₁ = F₂
state_after: no goals
Theorem: UpperHalfPlane.c_mul_im_sq_le_normSq_denom
File: Mathlib/Analysis/Complex/UpperHalfPlane/Basic.lean

tactic: let c := (↑ₘg 1 0 : ℝ)
state_before: z : ℍ
g : SL(2, ℝ)
⊢ (↑↑(toGLPos g) 1 0 * z.im) ^ 2 ≤ Complex.normSq (denom (toGLPos g) z)
state_after: z : ℍ
g : SL(2, ℝ)
c : ℝ := ↑↑(toGLPos g) 1 0
⊢ (↑↑(toGLPos g) 1 0 * z.im) ^ 2 ≤ Complex.normSq (denom (toGLPos g) z)

tactic: let d := (↑ₘg 1 1 : ℝ)
state_before: z : ℍ
g : SL(2, ℝ)
c : ℝ := ↑↑(toGLPos g) 1 0
⊢ (↑↑(toGLPos g) 1 0 * z.im) ^ 2 ≤ Complex.normSq (denom (toGLPos g) z)
state_after: z : ℍ
g : SL(2, ℝ)
c : ℝ := ↑↑(toGLPos g) 1 0
d : ℝ := ↑↑(toGLPos g) 1 1
⊢ (↑↑(toGLPos g) 1 0 * z.im) ^ 2 ≤ Complex.normSq (denom (toGLPos g) z)

tactic: calc
  (c * z.im) ^ 2 ≤ (c * z.im) ^ 2 + (c * z.re + d) ^ 2 := by nlinarith
  _ = Complex.normSq (denom g z) := by dsimp [c, d, denom, Complex.normSq]; ring
state_before: z : ℍ
g : SL(2, ℝ)
c : ℝ := ↑↑(toGLPos g) 1 0
d : ℝ := ↑↑(toGLPos g) 1 1
⊢ (↑↑(toGLPos g) 1 0 * z.im) ^ 2 ≤ Complex.normSq (denom (toGLPos g) z)
state_after: no goals

tactic: nlinarith
state_before: z : ℍ
g : SL(2, ℝ)
c : ℝ := ↑↑(toGLPos g) 1 0
d : ℝ := ↑↑(toGLPos g) 1 1
⊢ (c * z.im) ^ 2 ≤ (c * z.im) ^ 2 + (c * z.re + d) ^ 2
state_after: no goals

tactic: dsimp [c, d, denom, Complex.normSq]
state_before: z : ℍ
g : SL(2, ℝ)
c : ℝ := ↑↑(toGLPos g) 1 0
d : ℝ := ↑↑(toGLPos g) 1 1
⊢ (c * z.im) ^ 2 + (c * z.re + d) ^ 2 = Complex.normSq (denom (toGLPos g) z)
state_after: z : ℍ
g : SL(2, ℝ)
c : ℝ := ↑↑(toGLPos g) 1 0
d : ℝ := ↑↑(toGLPos g) 1 1
⊢ (↑g 1 0 * z.im) ^ 2 + (↑g 1 0 * z.re + ↑g 1 1) ^ 2 =
    (↑g 1 0 * z.re - 0 * z.im + ↑g 1 1) * (↑g 1 0 * z.re - 0 * z.im + ↑g 1 1) +
      (↑g 1 0 * z.im + 0 * z.re + 0) * (↑g 1 0 * z.im + 0 * z.re + 0)

tactic: ring
state_before: z : ℍ
g : SL(2, ℝ)
c : ℝ := ↑↑(toGLPos g) 1 0
d : ℝ := ↑↑(toGLPos g) 1 1
⊢ (↑g 1 0 * z.im) ^ 2 + (↑g 1 0 * z.re + ↑g 1 1) ^ 2 =
    (↑g 1 0 * z.re - 0 * z.im + ↑g 1 1) * (↑g 1 0 * z.re - 0 * z.im + ↑g 1 1) +
      (↑g 1 0 * z.im + 0 * z.re + 0) * (↑g 1 0 * z.im + 0 * z.re + 0)
state_after: no goals
Theorem: Filter.Tendsto.subseq_mem_entourage
File: Mathlib/Topology/UniformSpace/Cauchy.lean

tactic: rcases mem_atTop_sets.1 (hu (ball_mem_nhds a (symm_le_uniformity <| hV 0))) with ⟨n, hn⟩
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
V : ℕ → Set (α × α)
hV : ∀ (n : ℕ), V n ∈ 𝓤 α
u : ℕ → α
a : α
hu : Tendsto u atTop (𝓝 a)
⊢ ∃ φ, StrictMono φ ∧ (u (φ 0), a) ∈ V 0 ∧ ∀ (n : ℕ), (u (φ (n + 1)), u (φ n)) ∈ V (n + 1)
state_after: case intro
α : Type u
β : Type v
uniformSpace : UniformSpace α
V : ℕ → Set (α × α)
hV : ∀ (n : ℕ), V n ∈ 𝓤 α
u : ℕ → α
a : α
hu : Tendsto u atTop (𝓝 a)
n : ℕ
hn : ∀ b ≥ n, b ∈ u ⁻¹' ball a (Prod.swap ⁻¹' V 0)
⊢ ∃ φ, StrictMono φ ∧ (u (φ 0), a) ∈ V 0 ∧ ∀ (n : ℕ), (u (φ (n + 1)), u (φ n)) ∈ V (n + 1)

tactic: rcases (hu.comp (tendsto_add_atTop_nat n)).cauchySeq.subseq_mem fun n => hV (n + 1) with
  ⟨φ, φ_mono, hφV⟩
state_before: case intro
α : Type u
β : Type v
uniformSpace : UniformSpace α
V : ℕ → Set (α × α)
hV : ∀ (n : ℕ), V n ∈ 𝓤 α
u : ℕ → α
a : α
hu : Tendsto u atTop (𝓝 a)
n : ℕ
hn : ∀ b ≥ n, b ∈ u ⁻¹' ball a (Prod.swap ⁻¹' V 0)
⊢ ∃ φ, StrictMono φ ∧ (u (φ 0), a) ∈ V 0 ∧ ∀ (n : ℕ), (u (φ (n + 1)), u (φ n)) ∈ V (n + 1)
state_after: case intro.intro.intro
α : Type u
β : Type v
uniformSpace : UniformSpace α
V : ℕ → Set (α × α)
hV : ∀ (n : ℕ), V n ∈ 𝓤 α
u : ℕ → α
a : α
hu : Tendsto u atTop (𝓝 a)
n : ℕ
hn : ∀ b ≥ n, b ∈ u ⁻¹' ball a (Prod.swap ⁻¹' V 0)
φ : ℕ → ℕ
φ_mono : StrictMono φ
hφV : ∀ (n_1 : ℕ), ((u ∘ fun a => a + n) (φ (n_1 + 1)), (u ∘ fun a => a + n) (φ n_1)) ∈ V (n_1 + 1)
⊢ ∃ φ, StrictMono φ ∧ (u (φ 0), a) ∈ V 0 ∧ ∀ (n : ℕ), (u (φ (n + 1)), u (φ n)) ∈ V (n + 1)

tactic: exact ⟨fun k => φ k + n, φ_mono.add_const _, hn _ le_add_self, hφV⟩
state_before: case intro.intro.intro
α : Type u
β : Type v
uniformSpace : UniformSpace α
V : ℕ → Set (α × α)
hV : ∀ (n : ℕ), V n ∈ 𝓤 α
u : ℕ → α
a : α
hu : Tendsto u atTop (𝓝 a)
n : ℕ
hn : ∀ b ≥ n, b ∈ u ⁻¹' ball a (Prod.swap ⁻¹' V 0)
φ : ℕ → ℕ
φ_mono : StrictMono φ
hφV : ∀ (n_1 : ℕ), ((u ∘ fun a => a + n) (φ (n_1 + 1)), (u ∘ fun a => a + n) (φ n_1)) ∈ V (n_1 + 1)
⊢ ∃ φ, StrictMono φ ∧ (u (φ 0), a) ∈ V 0 ∧ ∀ (n : ℕ), (u (φ (n + 1)), u (φ n)) ∈ V (n + 1)
state_after: no goals
Theorem: CategoryTheory.ShortComplex.LeftHomologyData.ofIsColimitCokernelCofork_f'
File: Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean

tactic: rw [← cancel_mono (ofIsColimitCokernelCofork S hg c hc).i, f'_i,
  ofIsColimitCokernelCofork_i]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.LeftHomologyData
A : C
hg : S.g = 0
c : CokernelCofork S.f
hc : IsColimit c
⊢ (ofIsColimitCokernelCofork S hg c hc).f' = S.f
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.LeftHomologyData
A : C
hg : S.g = 0
c : CokernelCofork S.f
hc : IsColimit c
⊢ S.f = S.f ≫ 𝟙 S.X₂

tactic: rw [comp_id]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.LeftHomologyData
A : C
hg : S.g = 0
c : CokernelCofork S.f
hc : IsColimit c
⊢ S.f = S.f ≫ 𝟙 S.X₂
state_after: no goals
Theorem: ProbabilityTheory.kernel.prodMkRight_zero
File: Mathlib/Probability/Kernel/Composition.lean

tactic: ext x s _
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
δ : Type u_4
mδ : MeasurableSpace δ
γ : Type u_5
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
⊢ prodMkRight α 0 = 0
state_after: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
δ : Type u_4
mδ : MeasurableSpace δ
γ : Type u_5
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
x : β × α
s : Set γ
a✝ : MeasurableSet s
⊢ ((prodMkRight α 0) x) s = (0 x) s

tactic: simp
state_before: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
δ : Type u_4
mδ : MeasurableSpace δ
γ : Type u_5
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
x : β × α
s : Set γ
a✝ : MeasurableSet s
⊢ ((prodMkRight α 0) x) s = (0 x) s
state_after: no goals
Theorem: multiplicity.ne_zero_of_finite
File: Mathlib/RingTheory/Multiplicity.lean

tactic: simp [hb] at hn
state_before: α : Type u_1
β : Type u_2
inst✝ : MonoidWithZero α
a b : α
h : Finite a b
n : ℕ
hn : ¬a ^ (n + 1) ∣ b
hb : b = 0
⊢ False
state_after: no goals
Theorem: MeasureTheory.exp_llr_of_ac
File: Mathlib/MeasureTheory/Measure/LogLikelihoodRatio.lean

tactic: filter_upwards [hμν.ae_le (exp_llr μ ν), Measure.rnDeriv_pos hμν] with x hx_eq hx_pos
state_before: α : Type u_1
mα : MeasurableSpace α
μ✝ ν✝ : Measure α
f : α → ℝ
μ ν : Measure α
inst✝¹ : SigmaFinite μ
inst✝ : μ.HaveLebesgueDecomposition ν
hμν : μ ≪ ν
⊢ (fun x => rexp (llr μ ν x)) =ᶠ[ae μ] fun x => (μ.rnDeriv ν x).toReal
state_after: case h
α : Type u_1
mα : MeasurableSpace α
μ✝ ν✝ : Measure α
f : α → ℝ
μ ν : Measure α
inst✝¹ : SigmaFinite μ
inst✝ : μ.HaveLebesgueDecomposition ν
hμν : μ ≪ ν
x : α
hx_eq : rexp (llr μ ν x) = if μ.rnDeriv ν x = 0 then 1 else (μ.rnDeriv ν x).toReal
hx_pos : 0 < μ.rnDeriv ν x
⊢ rexp (llr μ ν x) = (μ.rnDeriv ν x).toReal

tactic: rw [hx_eq, if_neg hx_pos.ne']
state_before: case h
α : Type u_1
mα : MeasurableSpace α
μ✝ ν✝ : Measure α
f : α → ℝ
μ ν : Measure α
inst✝¹ : SigmaFinite μ
inst✝ : μ.HaveLebesgueDecomposition ν
hμν : μ ≪ ν
x : α
hx_eq : rexp (llr μ ν x) = if μ.rnDeriv ν x = 0 then 1 else (μ.rnDeriv ν x).toReal
hx_pos : 0 < μ.rnDeriv ν x
⊢ rexp (llr μ ν x) = (μ.rnDeriv ν x).toReal
state_after: no goals
Theorem: nhds_le_nhdsSet_iff
File: Mathlib/Topology/Separation.lean

tactic: rw [← nhdsSet_singleton, nhdsSet_le_iff, singleton_subset_iff]
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
s : Set X
x : X
⊢ 𝓝 x ≤ 𝓝ˢ s ↔ x ∈ s
state_after: no goals
Theorem: homology'.π_desc
File: Mathlib/Algebra/Homology/ImageToKernel.lean

tactic: simp [homology'.π, homology'.desc]
state_before: ι : Type u_1
V : Type u
inst✝⁴ : Category.{v, u} V
inst✝³ : HasZeroMorphisms V
A B C : V
f : A ⟶ B
inst✝² : HasImage f
g : B ⟶ C
inst✝¹ : HasKernel g
w : f ≫ g = 0
inst✝ : HasCokernel (imageToKernel f g w)
D : V
k : Subobject.underlying.obj (kernelSubobject g) ⟶ D
p : imageToKernel f g w ≫ k = 0
⊢ π f g w ≫ desc f g w k p = k
state_after: no goals
Theorem: Set.Finite.toFinset_inter
File: Mathlib/Data/Set/Finite.lean

tactic: ext
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
a : α
hs✝ : s.Finite
ht✝ : t.Finite
inst✝ : DecidableEq α
hs : s.Finite
ht : t.Finite
h : (s ∩ t).Finite
⊢ h.toFinset = hs.toFinset ∩ ht.toFinset
state_after: case a
α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
a : α
hs✝ : s.Finite
ht✝ : t.Finite
inst✝ : DecidableEq α
hs : s.Finite
ht : t.Finite
h : (s ∩ t).Finite
a✝ : α
⊢ a✝ ∈ h.toFinset ↔ a✝ ∈ hs.toFinset ∩ ht.toFinset

tactic: simp
state_before: case a
α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
a : α
hs✝ : s.Finite
ht✝ : t.Finite
inst✝ : DecidableEq α
hs : s.Finite
ht : t.Finite
h : (s ∩ t).Finite
a✝ : α
⊢ a✝ ∈ h.toFinset ↔ a✝ ∈ hs.toFinset ∩ ht.toFinset
state_after: no goals
Theorem: Submodule.IsPrincipal.associated_generator_span_self
File: Mathlib/RingTheory/PrincipalIdealDomain.lean

tactic: rw [← Ideal.span_singleton_eq_span_singleton]
state_before: R : Type u
M : Type v
inst✝⁴ : AddCommGroup M
inst✝³ : CommRing R
inst✝² : Module R M
inst✝¹ : IsPrincipalIdealRing R
inst✝ : IsDomain R
r : R
⊢ Associated (generator (Ideal.span {r})) r
state_after: R : Type u
M : Type v
inst✝⁴ : AddCommGroup M
inst✝³ : CommRing R
inst✝² : Module R M
inst✝¹ : IsPrincipalIdealRing R
inst✝ : IsDomain R
r : R
⊢ Ideal.span {generator (Ideal.span {r})} = Ideal.span {r}

tactic: exact Ideal.span_singleton_generator _
state_before: R : Type u
M : Type v
inst✝⁴ : AddCommGroup M
inst✝³ : CommRing R
inst✝² : Module R M
inst✝¹ : IsPrincipalIdealRing R
inst✝ : IsDomain R
r : R
⊢ Ideal.span {generator (Ideal.span {r})} = Ideal.span {r}
state_after: no goals