1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Batteries.UnionFind.le_rank_root
File: .lake/packages/batteries/Batteries/Data/UnionFind/Basic.lean

tactic: if h : self.parent x = x then
  rw [rootD_eq_self.2 h]; exact Nat.le_refl ..
else
  have := Nat.sub_lt_sub_left (self.lt_rankMax x) (self.rank_lt h)
  rw [← rootD_parent]
  exact Nat.le_trans (Nat.le_of_lt (self.rank_lt h)) le_rank_root
state_before: self : UnionFind
x : Nat
⊢ self.rank x ≤ self.rank (self.rootD x)
state_after: no goals

tactic: rw [rootD_eq_self.2 h]
state_before: self : UnionFind
x : Nat
h : self.parent x = x
⊢ self.rank x ≤ self.rank (self.rootD x)
state_after: self : UnionFind
x : Nat
h : self.parent x = x
⊢ self.rank x ≤ self.rank x

tactic: exact Nat.le_refl ..
state_before: self : UnionFind
x : Nat
h : self.parent x = x
⊢ self.rank x ≤ self.rank x
state_after: no goals

tactic: have := Nat.sub_lt_sub_left (self.lt_rankMax x) (self.rank_lt h)
state_before: self : UnionFind
x : Nat
h : ¬self.parent x = x
⊢ self.rank x ≤ self.rank (self.rootD x)
state_after: self : UnionFind
x : Nat
h : ¬self.parent x = x
this : self.rankMax - self.rank (self.parent x) < self.rankMax - self.rank x
⊢ self.rank x ≤ self.rank (self.rootD x)

tactic: rw [← rootD_parent]
state_before: self : UnionFind
x : Nat
h : ¬self.parent x = x
this : self.rankMax - self.rank (self.parent x) < self.rankMax - self.rank x
⊢ self.rank x ≤ self.rank (self.rootD x)
state_after: self : UnionFind
x : Nat
h : ¬self.parent x = x
this : self.rankMax - self.rank (self.parent x) < self.rankMax - self.rank x
⊢ self.rank x ≤ self.rank (self.rootD (self.parent x))

tactic: exact Nat.le_trans (Nat.le_of_lt (self.rank_lt h)) le_rank_root
state_before: self : UnionFind
x : Nat
h : ¬self.parent x = x
this : self.rankMax - self.rank (self.parent x) < self.rankMax - self.rank x
⊢ self.rank x ≤ self.rank (self.rootD (self.parent x))
state_after: no goals
Theorem: MeasureTheory.predictablePart_bdd_difference
File: Mathlib/Probability/Martingale/Centering.lean

tactic: simp_rw [predictablePart, Finset.sum_apply, Finset.sum_range_succ_sub_sum]
state_before: Ω : Type u_1
E : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f✝ : ℕ → Ω → E
ℱ✝ : Filtration ℕ m0
n : ℕ
R : ℝ≥0
f : ℕ → Ω → ℝ
ℱ : Filtration ℕ m0
hbdd : ∀ᵐ (ω : Ω) ∂μ, ∀ (i : ℕ), |f (i + 1) ω - f i ω| ≤ ↑R
⊢ ∀ᵐ (ω : Ω) ∂μ, ∀ (i : ℕ), |predictablePart f ℱ μ (i + 1) ω - predictablePart f ℱ μ i ω| ≤ ↑R
state_after: Ω : Type u_1
E : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f✝ : ℕ → Ω → E
ℱ✝ : Filtration ℕ m0
n : ℕ
R : ℝ≥0
f : ℕ → Ω → ℝ
ℱ : Filtration ℕ m0
hbdd : ∀ᵐ (ω : Ω) ∂μ, ∀ (i : ℕ), |f (i + 1) ω - f i ω| ≤ ↑R
⊢ ∀ᵐ (ω : Ω) ∂μ, ∀ (i : ℕ), |(μ[f (i + 1) - f i|↑ℱ i]) ω| ≤ ↑R

tactic: exact ae_all_iff.2 fun i => ae_bdd_condexp_of_ae_bdd <| ae_all_iff.1 hbdd i
state_before: Ω : Type u_1
E : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f✝ : ℕ → Ω → E
ℱ✝ : Filtration ℕ m0
n : ℕ
R : ℝ≥0
f : ℕ → Ω → ℝ
ℱ : Filtration ℕ m0
hbdd : ∀ᵐ (ω : Ω) ∂μ, ∀ (i : ℕ), |f (i + 1) ω - f i ω| ≤ ↑R
⊢ ∀ᵐ (ω : Ω) ∂μ, ∀ (i : ℕ), |(μ[f (i + 1) - f i|↑ℱ i]) ω| ≤ ↑R
state_after: no goals
Theorem: GromovHausdorff.maxVar_bound
File: Mathlib/Topology/MetricSpace/GromovHausdorffRealized.lean

tactic: rw [range_inl_union_range_inr]
state_before: X : Type u
Y : Type v
inst✝⁵ : MetricSpace X
inst✝⁴ : CompactSpace X
inst✝³ : Nonempty X
inst✝² : MetricSpace Y
inst✝¹ : CompactSpace Y
inst✝ : Nonempty Y
f : GromovHausdorff.ProdSpaceFun X Y
x y z t : X ⊕ Y
⊢ diam univ = diam (range inl ∪ range inr)
state_after: no goals

tactic: rw [isometry_inl.diam_range, isometry_inr.diam_range]
state_before: X : Type u
Y : Type v
inst✝⁵ : MetricSpace X
inst✝⁴ : CompactSpace X
inst✝³ : Nonempty X
inst✝² : MetricSpace Y
inst✝¹ : CompactSpace Y
inst✝ : Nonempty Y
f : GromovHausdorff.ProdSpaceFun X Y
x y z t : X ⊕ Y
⊢ diam (range inl) + dist (inl default) (inr default) + diam (range inr) =
    diam univ + (dist default default + 1 + dist default default) + diam univ
state_after: X : Type u
Y : Type v
inst✝⁵ : MetricSpace X
inst✝⁴ : CompactSpace X
inst✝³ : Nonempty X
inst✝² : MetricSpace Y
inst✝¹ : CompactSpace Y
inst✝ : Nonempty Y
f : GromovHausdorff.ProdSpaceFun X Y
x y z t : X ⊕ Y
⊢ diam univ + dist (inl default) (inr default) + diam univ =
    diam univ + (dist default default + 1 + dist default default) + diam univ

tactic: rfl
state_before: X : Type u
Y : Type v
inst✝⁵ : MetricSpace X
inst✝⁴ : CompactSpace X
inst✝³ : Nonempty X
inst✝² : MetricSpace Y
inst✝¹ : CompactSpace Y
inst✝ : Nonempty Y
f : GromovHausdorff.ProdSpaceFun X Y
x y z t : X ⊕ Y
⊢ diam univ + dist (inl default) (inr default) + diam univ =
    diam univ + (dist default default + 1 + dist default default) + diam univ
state_after: no goals

tactic: simp
state_before: X : Type u
Y : Type v
inst✝⁵ : MetricSpace X
inst✝⁴ : CompactSpace X
inst✝³ : Nonempty X
inst✝² : MetricSpace Y
inst✝¹ : CompactSpace Y
inst✝ : Nonempty Y
f : GromovHausdorff.ProdSpaceFun X Y
x y z t : X ⊕ Y
⊢ diam univ + (dist default default + 1 + dist default default) + diam univ = 1 * diam univ + 1 + 1 * diam univ
state_after: no goals

tactic: gcongr <;> norm_num
state_before: X : Type u
Y : Type v
inst✝⁵ : MetricSpace X
inst✝⁴ : CompactSpace X
inst✝³ : Nonempty X
inst✝² : MetricSpace Y
inst✝¹ : CompactSpace Y
inst✝ : Nonempty Y
f : GromovHausdorff.ProdSpaceFun X Y
x y z t : X ⊕ Y
⊢ 1 * diam univ + 1 + 1 * diam univ ≤ 2 * diam univ + 1 + 2 * diam univ
state_after: no goals
Theorem: Set.Ico_mul_Ioc_subset'
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: haveI := covariantClass_le_of_lt
state_before: α : Type u_1
inst✝³ : Mul α
inst✝² : PartialOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (Function.swap HMul.hMul) LT.lt
a b c d : α
⊢ Ico a b * Ioc c d ⊆ Ioo (a * c) (b * d)
state_after: α : Type u_1
inst✝³ : Mul α
inst✝² : PartialOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (Function.swap HMul.hMul) LT.lt
a b c d : α
this :
  ∀ (M : Type ?u.7886) (N : Type ?u.7885) (μ : M → N → N) [inst : PartialOrder N]
    [inst_1 : CovariantClass M N μ fun x x_1 => x < x_1], CovariantClass M N μ fun x x_1 => x ≤ x_1
⊢ Ico a b * Ioc c d ⊆ Ioo (a * c) (b * d)

tactic: rintro x ⟨y, ⟨hya, hyb⟩, z, ⟨hzc, hzd⟩, rfl⟩
state_before: α : Type u_1
inst✝³ : Mul α
inst✝² : PartialOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (Function.swap HMul.hMul) LT.lt
a b c d : α
this :
  ∀ (M : Type ?u.7886) (N : Type ?u.7885) (μ : M → N → N) [inst : PartialOrder N]
    [inst_1 : CovariantClass M N μ fun x x_1 => x < x_1], CovariantClass M N μ fun x x_1 => x ≤ x_1
⊢ Ico a b * Ioc c d ⊆ Ioo (a * c) (b * d)
state_after: case intro.intro.intro.intro.intro.intro
α : Type u_1
inst✝³ : Mul α
inst✝² : PartialOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (Function.swap HMul.hMul) LT.lt
a b c d : α
this :
  ∀ (M : Type ?u.7886) (N : Type ?u.7885) (μ : M → N → N) [inst : PartialOrder N]
    [inst_1 : CovariantClass M N μ fun x x_1 => x < x_1], CovariantClass M N μ fun x x_1 => x ≤ x_1
y : α
hya : a ≤ y
hyb : y < b
z : α
hzc : c < z
hzd : z ≤ d
⊢ (fun x x_1 => x * x_1) y z ∈ Ioo (a * c) (b * d)

tactic: exact ⟨mul_lt_mul_of_le_of_lt hya hzc, mul_lt_mul_of_lt_of_le hyb hzd⟩
state_before: case intro.intro.intro.intro.intro.intro
α : Type u_1
inst✝³ : Mul α
inst✝² : PartialOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (Function.swap HMul.hMul) LT.lt
a b c d : α
this :
  ∀ (M : Type ?u.7886) (N : Type ?u.7885) (μ : M → N → N) [inst : PartialOrder N]
    [inst_1 : CovariantClass M N μ fun x x_1 => x < x_1], CovariantClass M N μ fun x x_1 => x ≤ x_1
y : α
hya : a ≤ y
hyb : y < b
z : α
hzc : c < z
hzd : z ≤ d
⊢ (fun x x_1 => x * x_1) y z ∈ Ioo (a * c) (b * d)
state_after: no goals
Theorem: ZMod.mul_inv_eq_gcd
File: Mathlib/Data/ZMod/Basic.lean

tactic: cases' n with n
state_before: n : ℕ
a : ZMod n
⊢ a * a⁻¹ = ↑(a.val.gcd n)
state_after: case zero
a : ZMod 0
⊢ a * a⁻¹ = ↑(a.val.gcd 0)

case succ
n : ℕ
a : ZMod (n + 1)
⊢ a * a⁻¹ = ↑(a.val.gcd (n + 1))

tactic: dsimp [ZMod] at a ⊢
state_before: case zero
a : ZMod 0
⊢ a * a⁻¹ = ↑(a.val.gcd 0)
state_after: case zero
a : ℤ
⊢ a * a⁻¹ = ↑((val a).gcd 0)

tactic: calc
  _ = a * Int.sign a := rfl
  _ = a.natAbs := by rw [Int.mul_sign]
  _ = a.natAbs.gcd 0 := by rw [Nat.gcd_zero_right]
state_before: case zero
a : ℤ
⊢ a * a⁻¹ = ↑((val a).gcd 0)
state_after: no goals

tactic: rw [Int.mul_sign]
state_before: a : ℤ
⊢ a * a.sign = ↑a.natAbs
state_after: no goals

tactic: rw [Nat.gcd_zero_right]
state_before: a : ℤ
⊢ ↑a.natAbs = ↑(a.natAbs.gcd 0)
state_after: no goals

tactic: calc
  a * a⁻¹ = a * a⁻¹ + n.succ * Nat.gcdB (val a) n.succ := by
    rw [natCast_self, zero_mul, add_zero]
  _ = ↑(↑a.val * Nat.gcdA (val a) n.succ + n.succ * Nat.gcdB (val a) n.succ) := by
    push_cast
    rw [natCast_zmod_val]
    rfl
  _ = Nat.gcd a.val n.succ := by rw [← Nat.gcd_eq_gcd_ab a.val n.succ]; rfl
state_before: case succ
n : ℕ
a : ZMod (n + 1)
⊢ a * a⁻¹ = ↑(a.val.gcd (n + 1))
state_after: no goals

tactic: rw [natCast_self, zero_mul, add_zero]
state_before: n : ℕ
a : ZMod (n + 1)
⊢ a * a⁻¹ = a * a⁻¹ + ↑n.succ * ↑(a.val.gcdB n.succ)
state_after: no goals

tactic: push_cast
state_before: n : ℕ
a : ZMod (n + 1)
⊢ a * a⁻¹ + ↑n.succ * ↑(a.val.gcdB n.succ) = ↑(↑a.val * a.val.gcdA n.succ + ↑n.succ * a.val.gcdB n.succ)
state_after: n : ℕ
a : ZMod (n + 1)
⊢ a * a⁻¹ + (↑n + 1) * ↑(a.val.gcdB n.succ) = ↑a.val * ↑(a.val.gcdA n.succ) + (↑n + 1) * ↑(a.val.gcdB n.succ)

tactic: rw [natCast_zmod_val]
state_before: n : ℕ
a : ZMod (n + 1)
⊢ a * a⁻¹ + (↑n + 1) * ↑(a.val.gcdB n.succ) = ↑a.val * ↑(a.val.gcdA n.succ) + (↑n + 1) * ↑(a.val.gcdB n.succ)
state_after: n : ℕ
a : ZMod (n + 1)
⊢ a * a⁻¹ + (↑n + 1) * ↑(a.val.gcdB n.succ) = a * ↑(a.val.gcdA n.succ) + (↑n + 1) * ↑(a.val.gcdB n.succ)

tactic: rfl
state_before: n : ℕ
a : ZMod (n + 1)
⊢ a * a⁻¹ + (↑n + 1) * ↑(a.val.gcdB n.succ) = a * ↑(a.val.gcdA n.succ) + (↑n + 1) * ↑(a.val.gcdB n.succ)
state_after: no goals

tactic: rw [← Nat.gcd_eq_gcd_ab a.val n.succ]
state_before: n : ℕ
a : ZMod (n + 1)
⊢ ↑(↑a.val * a.val.gcdA n.succ + ↑n.succ * a.val.gcdB n.succ) = ↑(a.val.gcd n.succ)
state_after: n : ℕ
a : ZMod (n + 1)
⊢ ↑↑(a.val.gcd n.succ) = ↑(a.val.gcd n.succ)

tactic: rfl
state_before: n : ℕ
a : ZMod (n + 1)
⊢ ↑↑(a.val.gcd n.succ) = ↑(a.val.gcd n.succ)
state_after: no goals
Theorem: PowerSeries.X_ne_zero
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: simpa only [coeff_one_X, one_ne_zero, map_zero] using congr_arg (coeff R 1) H
state_before: R : Type u_1
inst✝¹ : Semiring R
inst✝ : Nontrivial R
H : X = 0
⊢ False
state_after: no goals
Theorem: Polynomial.one_mem_nthRootsFinset
File: Mathlib/Algebra/Polynomial/Roots.lean

tactic: rw [mem_nthRootsFinset hn, one_pow]
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
hn : 0 < n
⊢ 1 ∈ nthRootsFinset n R
state_after: no goals
Theorem: NNReal.hasSum_iff_tendsto_nat
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: rw [← ENNReal.hasSum_coe, ENNReal.hasSum_iff_tendsto_nat]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : ℕ → ℝ≥0
r : ℝ≥0
⊢ HasSum f r ↔ Tendsto (fun n => ∑ i ∈ Finset.range n, f i) atTop (𝓝 r)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
f : ℕ → ℝ≥0
r : ℝ≥0
⊢ Tendsto (fun n => ∑ i ∈ Finset.range n, ↑(f i)) atTop (𝓝 ↑r) ↔
    Tendsto (fun n => ∑ i ∈ Finset.range n, f i) atTop (𝓝 r)

tactic: simp only [← ENNReal.coe_finset_sum]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : ℕ → ℝ≥0
r : ℝ≥0
⊢ Tendsto (fun n => ∑ i ∈ Finset.range n, ↑(f i)) atTop (𝓝 ↑r) ↔
    Tendsto (fun n => ∑ i ∈ Finset.range n, f i) atTop (𝓝 r)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
f : ℕ → ℝ≥0
r : ℝ≥0
⊢ Tendsto (fun n => ↑(∑ a ∈ Finset.range n, f a)) atTop (𝓝 ↑r) ↔
    Tendsto (fun n => ∑ a ∈ Finset.range n, f a) atTop (𝓝 r)

tactic: exact ENNReal.tendsto_coe
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : ℕ → ℝ≥0
r : ℝ≥0
⊢ Tendsto (fun n => ↑(∑ a ∈ Finset.range n, f a)) atTop (𝓝 ↑r) ↔
    Tendsto (fun n => ∑ a ∈ Finset.range n, f a) atTop (𝓝 r)
state_after: no goals
Theorem: equicontinuousOn_iInf_rng
File: Mathlib/Topology/UniformSpace/Equicontinuity.lean

tactic: simp_rw [EquicontinuousOn, equicontinuousWithinAt_iInf_rng, @forall_swap _ κ]
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
u : κ → UniformSpace α'
F : ι → X → α'
S : Set X
⊢ EquicontinuousOn F S ↔ ∀ (k : κ), EquicontinuousOn F S
state_after: no goals
Theorem: Complex.ball_one_subset_slitPlane
File: Mathlib/Analysis/Complex/Basic.lean

tactic: linarith
state_before: z : ℂ
hz : z ∈ Metric.ball 1 1
this : -1 < z.re - 1
⊢ 0 < z.re
state_after: no goals
Theorem: List.map_comp_map
File: Mathlib/Data/List/Basic.lean

tactic: ext l
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
g : β → γ
f : α → β
⊢ map g ∘ map f = map (g ∘ f)
state_after: case h.h.a
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
g : β → γ
f : α → β
l : List α
n✝ : ℕ
a✝ : γ
⊢ a✝ ∈ ((map g ∘ map f) l)[n✝]? ↔ a✝ ∈ (map (g ∘ f) l)[n✝]?

tactic: rw [comp_map, Function.comp_apply]
state_before: case h.h.a
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
g : β → γ
f : α → β
l : List α
n✝ : ℕ
a✝ : γ
⊢ a✝ ∈ ((map g ∘ map f) l)[n✝]? ↔ a✝ ∈ (map (g ∘ f) l)[n✝]?
state_after: no goals
Theorem: Seminorm.ball_sup
File: Mathlib/Analysis/Seminorm.lean

tactic: simp_rw [ball, ← Set.setOf_and, coe_sup, Pi.sup_apply, sup_lt_iff]
state_before: R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : SMul 𝕜 E
p✝ : Seminorm 𝕜 E
x y : E
r✝ : ℝ
p q : Seminorm 𝕜 E
e : E
r : ℝ
⊢ (p ⊔ q).ball e r = p.ball e r ∩ q.ball e r
state_after: no goals
Theorem: CompositionAsSet.boundary_zero
File: Mathlib/Combinatorics/Enumerative/Composition.lean

tactic: rw [boundary, Finset.orderEmbOfFin_zero rfl c.card_boundaries_pos]
state_before: n : ℕ
c : CompositionAsSet n
⊢ c.boundary ⟨0, ⋯⟩ = 0
state_after: n : ℕ
c : CompositionAsSet n
⊢ c.boundaries.min' ⋯ = 0

tactic: exact le_antisymm (Finset.min'_le _ _ c.zero_mem) (Fin.zero_le _)
state_before: n : ℕ
c : CompositionAsSet n
⊢ c.boundaries.min' ⋯ = 0
state_after: no goals
Theorem: MeasureTheory.Measure.rnDeriv_withDensity₀
File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

tactic: rw [zero_add]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν✝ ν : Measure α
inst✝ : SigmaFinite ν
f : α → ℝ≥0∞
hf : AEMeasurable f ν
⊢ ν.withDensity f = 0 + ν.withDensity f
state_after: no goals
Theorem: Equiv.Set.sumCompl_symm_apply_of_mem
File: Mathlib/Logic/Equiv/Set.lean

tactic: have : ((⟨x, Or.inl hx⟩ : (s ∪ sᶜ : Set α)) : α) ∈ s := hx
state_before: α✝ : Sort u
β : Sort v
γ : Sort w
α : Type u
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
x : α
hx : x ∈ s
⊢ (Set.sumCompl s).symm x = Sum.inl ⟨x, hx⟩
state_after: α✝ : Sort u
β : Sort v
γ : Sort w
α : Type u
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
x : α
hx : x ∈ s
this : ↑⟨x, ⋯⟩ ∈ s
⊢ (Set.sumCompl s).symm x = Sum.inl ⟨x, hx⟩

tactic: rw [Equiv.Set.sumCompl]
state_before: α✝ : Sort u
β : Sort v
γ : Sort w
α : Type u
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
x : α
hx : x ∈ s
this : ↑⟨x, ⋯⟩ ∈ s
⊢ (Set.sumCompl s).symm x = Sum.inl ⟨x, hx⟩
state_after: α✝ : Sort u
β : Sort v
γ : Sort w
α : Type u
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
x : α
hx : x ∈ s
this : ↑⟨x, ⋯⟩ ∈ s
⊢ (Trans.trans (Trans.trans (Set.union ⋯).symm (Set.ofEq ⋯)) (Set.univ α)).symm x = Sum.inl ⟨x, hx⟩

tactic: simpa using Set.union_apply_left (by simp) this
state_before: α✝ : Sort u
β : Sort v
γ : Sort w
α : Type u
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
x : α
hx : x ∈ s
this : ↑⟨x, ⋯⟩ ∈ s
⊢ (Trans.trans (Trans.trans (Set.union ⋯).symm (Set.ofEq ⋯)) (Set.univ α)).symm x = Sum.inl ⟨x, hx⟩
state_after: no goals

tactic: simp
state_before: α✝ : Sort u
β : Sort v
γ : Sort w
α : Type u
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
x : α
hx : x ∈ s
this : ↑⟨x, ⋯⟩ ∈ s
⊢ s ∩ sᶜ ⊆ ∅
state_after: no goals
Theorem: List.revzip_map_fst
File: Mathlib/Data/List/Zip.lean

tactic: rw [← unzip_left, unzip_revzip]
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
l : List α
⊢ map Prod.fst l.revzip = l
state_after: no goals
Theorem: IsGalois.IntermediateField.AdjoinSimple.card_aut_eq_finrank
File: Mathlib/FieldTheory/Galois.lean

tactic: letI : Fintype (F⟮α⟯ →ₐ[F] F⟮α⟯) := IntermediateField.fintypeOfAlgHomAdjoinIntegral F hα
state_before: F : Type u_1
inst✝³ : Field F
E : Type u_2
inst✝² : Field E
inst✝¹ : Algebra F E
inst✝ : FiniteDimensional F E
α : E
hα : IsIntegral F α
h_sep : (minpoly F α).Separable
h_splits : Polynomial.Splits (algebraMap F ↥F⟮α⟯) (minpoly F α)
⊢ Fintype.card (↥F⟮α⟯ ≃ₐ[F] ↥F⟮α⟯) = finrank F ↥F⟮α⟯
state_after: F : Type u_1
inst✝³ : Field F
E : Type u_2
inst✝² : Field E
inst✝¹ : Algebra F E
inst✝ : FiniteDimensional F E
α : E
hα : IsIntegral F α
h_sep : (minpoly F α).Separable
h_splits : Polynomial.Splits (algebraMap F ↥F⟮α⟯) (minpoly F α)
this : Fintype (↥F⟮α⟯ →ₐ[F] ↥F⟮α⟯) := IntermediateField.fintypeOfAlgHomAdjoinIntegral F hα
⊢ Fintype.card (↥F⟮α⟯ ≃ₐ[F] ↥F⟮α⟯) = finrank F ↥F⟮α⟯

tactic: rw [IntermediateField.adjoin.finrank hα]
state_before: F : Type u_1
inst✝³ : Field F
E : Type u_2
inst✝² : Field E
inst✝¹ : Algebra F E
inst✝ : FiniteDimensional F E
α : E
hα : IsIntegral F α
h_sep : (minpoly F α).Separable
h_splits : Polynomial.Splits (algebraMap F ↥F⟮α⟯) (minpoly F α)
this : Fintype (↥F⟮α⟯ →ₐ[F] ↥F⟮α⟯) := IntermediateField.fintypeOfAlgHomAdjoinIntegral F hα
⊢ Fintype.card (↥F⟮α⟯ ≃ₐ[F] ↥F⟮α⟯) = finrank F ↥F⟮α⟯
state_after: F : Type u_1
inst✝³ : Field F
E : Type u_2
inst✝² : Field E
inst✝¹ : Algebra F E
inst✝ : FiniteDimensional F E
α : E
hα : IsIntegral F α
h_sep : (minpoly F α).Separable
h_splits : Polynomial.Splits (algebraMap F ↥F⟮α⟯) (minpoly F α)
this : Fintype (↥F⟮α⟯ →ₐ[F] ↥F⟮α⟯) := IntermediateField.fintypeOfAlgHomAdjoinIntegral F hα
⊢ Fintype.card (↥F⟮α⟯ ≃ₐ[F] ↥F⟮α⟯) = (minpoly F α).natDegree

tactic: rw [← IntermediateField.card_algHom_adjoin_integral F hα h_sep h_splits]
state_before: F : Type u_1
inst✝³ : Field F
E : Type u_2
inst✝² : Field E
inst✝¹ : Algebra F E
inst✝ : FiniteDimensional F E
α : E
hα : IsIntegral F α
h_sep : (minpoly F α).Separable
h_splits : Polynomial.Splits (algebraMap F ↥F⟮α⟯) (minpoly F α)
this : Fintype (↥F⟮α⟯ →ₐ[F] ↥F⟮α⟯) := IntermediateField.fintypeOfAlgHomAdjoinIntegral F hα
⊢ Fintype.card (↥F⟮α⟯ ≃ₐ[F] ↥F⟮α⟯) = (minpoly F α).natDegree
state_after: F : Type u_1
inst✝³ : Field F
E : Type u_2
inst✝² : Field E
inst✝¹ : Algebra F E
inst✝ : FiniteDimensional F E
α : E
hα : IsIntegral F α
h_sep : (minpoly F α).Separable
h_splits : Polynomial.Splits (algebraMap F ↥F⟮α⟯) (minpoly F α)
this : Fintype (↥F⟮α⟯ →ₐ[F] ↥F⟮α⟯) := IntermediateField.fintypeOfAlgHomAdjoinIntegral F hα
⊢ Fintype.card (↥F⟮α⟯ ≃ₐ[F] ↥F⟮α⟯) = Fintype.card (↥F⟮α⟯ →ₐ[F] ↥F⟮α⟯)

tactic: exact Fintype.card_congr (algEquivEquivAlgHom F F⟮α⟯)
state_before: F : Type u_1
inst✝³ : Field F
E : Type u_2
inst✝² : Field E
inst✝¹ : Algebra F E
inst✝ : FiniteDimensional F E
α : E
hα : IsIntegral F α
h_sep : (minpoly F α).Separable
h_splits : Polynomial.Splits (algebraMap F ↥F⟮α⟯) (minpoly F α)
this : Fintype (↥F⟮α⟯ →ₐ[F] ↥F⟮α⟯) := IntermediateField.fintypeOfAlgHomAdjoinIntegral F hα
⊢ Fintype.card (↥F⟮α⟯ ≃ₐ[F] ↥F⟮α⟯) = Fintype.card (↥F⟮α⟯ →ₐ[F] ↥F⟮α⟯)
state_after: no goals
Theorem: FractionalIdeal.coe_ideal_span_singleton_div_self
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

tactic: rw [coeIdeal_span_singleton,
  spanSingleton_div_self K <|
    (map_ne_zero_iff _ <| NoZeroSMulDivisors.algebraMap_injective R₁ K).mpr hx]
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁹ : CommRing R
inst✝⁸ : CommRing A
inst✝⁷ : Field K
R₁ : Type u_4
inst✝⁶ : CommRing R₁
inst✝⁵ : IsDomain R₁
inst✝⁴ : Algebra R₁ K
inst✝³ : IsFractionRing R₁ K
I J : FractionalIdeal R₁⁰ K
K' : Type u_5
inst✝² : Field K'
inst✝¹ : Algebra R₁ K'
inst✝ : IsFractionRing R₁ K'
x : R₁
hx : x ≠ 0
⊢ ↑(Ideal.span {x}) / ↑(Ideal.span {x}) = 1
state_after: no goals
Theorem: Real.exp_neg
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [exp_neg]
state_before: x y : ℝ
⊢ ↑(rexp (-x)) = ↑(rexp x)⁻¹
state_after: no goals
Theorem: ContinuousLinearEquiv.comp_right_hasFDerivWithinAt_iff'
File: Mathlib/Analysis/Calculus/FDeriv/Equiv.lean

tactic: rw [← iso.comp_right_hasFDerivWithinAt_iff, ContinuousLinearMap.comp_assoc,
  iso.coe_symm_comp_coe, ContinuousLinearMap.comp_id]
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f'✝ f₀' f₁' g' e : E →L[𝕜] F
x✝ : E
s✝ t : Set E
L L₁ L₂ : Filter E
iso : E ≃L[𝕜] F
f : F → G
s : Set F
x : E
f' : E →L[𝕜] G
⊢ HasFDerivWithinAt (f ∘ ⇑iso) f' (⇑iso ⁻¹' s) x ↔ HasFDerivWithinAt f (f'.comp ↑iso.symm) s (iso x)
state_after: no goals
Theorem: SimpleGraph.Walk.map_toDeleteEdges_eq
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: rw [← transfer_eq_map_of_le, transfer_transfer, transfer_self]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w : V
s : Set (Sym2 V)
p : G.Walk v w
hp : ∀ e ∈ p.edges, e ∉ s
⊢ Walk.map (Hom.mapSpanningSubgraphs ⋯) (toDeleteEdges s p hp) = p
state_after: case hp'
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w : V
s : Set (Sym2 V)
p : G.Walk v w
hp : ∀ e ∈ p.edges, e ∉ s
⊢ ∀ e ∈ (p.transfer (G.deleteEdges s) ⋯).edges, e ∈ G.edgeSet

tactic: intros e
state_before: case hp'
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w : V
s : Set (Sym2 V)
p : G.Walk v w
hp : ∀ e ∈ p.edges, e ∉ s
⊢ ∀ e ∈ (p.transfer (G.deleteEdges s) ⋯).edges, e ∈ G.edgeSet
state_after: case hp'
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w : V
s : Set (Sym2 V)
p : G.Walk v w
hp : ∀ e ∈ p.edges, e ∉ s
e : Sym2 V
⊢ e ∈ (p.transfer (G.deleteEdges s) ⋯).edges → e ∈ G.edgeSet

tactic: rw [edges_transfer]
state_before: case hp'
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w : V
s : Set (Sym2 V)
p : G.Walk v w
hp : ∀ e ∈ p.edges, e ∉ s
e : Sym2 V
⊢ e ∈ (p.transfer (G.deleteEdges s) ⋯).edges → e ∈ G.edgeSet
state_after: case hp'
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w : V
s : Set (Sym2 V)
p : G.Walk v w
hp : ∀ e ∈ p.edges, e ∉ s
e : Sym2 V
⊢ e ∈ p.edges → e ∈ G.edgeSet

tactic: apply edges_subset_edgeSet p
state_before: case hp'
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w : V
s : Set (Sym2 V)
p : G.Walk v w
hp : ∀ e ∈ p.edges, e ∉ s
e : Sym2 V
⊢ e ∈ p.edges → e ∈ G.edgeSet
state_after: no goals
Theorem: Polynomial.coeff_X_of_ne_one
File: Mathlib/Algebra/Polynomial/Basic.lean

tactic: rw [coeff_X, if_neg hn.symm]
state_before: R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
hn : n ≠ 1
⊢ X.coeff n = 0
state_after: no goals
Theorem: AddMonoidAlgebra.of'_divOf
File: Mathlib/Algebra/MonoidAlgebra/Division.lean

tactic: simpa only [one_mul] using mul_of'_divOf (1 : k[G]) a
state_before: k : Type u_1
G : Type u_2
inst✝¹ : Semiring k
inst✝ : AddCancelCommMonoid G
a : G
⊢ of' k G a /ᵒᶠ a = 1
state_after: no goals