tasksource/leandojo huggingface dataset:
Theorem: Polynomial.coeff_mul_of_natDegree_le
File: Mathlib/Data/Polynomial/Degree/Lemmas.lean

tactic: rcases eq_or_lt_of_le pm with (rfl | hm) <;> rcases eq_or_lt_of_le qn with (rfl | hn)
state_before: R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
inst✝ : Semiring R
p q r : R[X]
pm : natDegree p ≤ m
qn : natDegree q ≤ n
⊢ coeff (p * q) (m + n) = coeff p m * coeff q n

tactic: exact natDegree_add_coeff_mul _ _
state_before: case inl.inl
R : Type u
S : Type v
ι : Type w
a b : R
inst✝ : Semiring R
p q r : R[X]
pm : natDegree p ≤ natDegree p
qn : natDegree q ≤ natDegree q
⊢ coeff (p * q) (natDegree p + natDegree q) = coeff p (natDegree p) * coeff q (natDegree q)

tactic: rw [coeff_eq_zero_of_natDegree_lt hn, mul_zero]
state_before: case inl.inr
R : Type u
S : Type v
ι : Type w
a b : R
n : ℕ
inst✝ : Semiring R
p q r : R[X]
qn : natDegree q ≤ n
pm : natDegree p ≤ natDegree p
hn : natDegree q < n
⊢ coeff (p * q) (natDegree p + n) = coeff p (natDegree p) * coeff q n

tactic: exact natDegree_lt_coeff_mul (add_lt_add_left hn _)
state_before: case inl.inr
R : Type u
S : Type v
ι : Type w
a b : R
n : ℕ
inst✝ : Semiring R
p q r : R[X]
qn : natDegree q ≤ n
pm : natDegree p ≤ natDegree p
hn : natDegree q < n
⊢ coeff (p * q) (natDegree p + n) = 0

tactic: rw [coeff_eq_zero_of_natDegree_lt hm, zero_mul]
state_before: case inr.inl
R : Type u
S : Type v
ι : Type w
a b : R
m : ℕ
inst✝ : Semiring R
p q r : R[X]
pm : natDegree p ≤ m
hm : natDegree p < m
qn : natDegree q ≤ natDegree q
⊢ coeff (p * q) (m + natDegree q) = coeff p m * coeff q (natDegree q)

tactic: exact natDegree_lt_coeff_mul (add_lt_add_right hm _)
state_before: case inr.inl
R : Type u
S : Type v
ι : Type w
a b : R
m : ℕ
inst✝ : Semiring R
p q r : R[X]
pm : natDegree p ≤ m
hm : natDegree p < m
qn : natDegree q ≤ natDegree q
⊢ coeff (p * q) (m + natDegree q) = 0

tactic: rw [coeff_eq_zero_of_natDegree_lt hn, mul_zero]
state_before: case inr.inr
R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
inst✝ : Semiring R
p q r : R[X]
pm : natDegree p ≤ m
qn : natDegree q ≤ n
hm : natDegree p < m
hn : natDegree q < n
⊢ coeff (p * q) (m + n) = coeff p m * coeff q n

tactic: exact natDegree_lt_coeff_mul (add_lt_add hm hn)
state_before: case inr.inr
R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
inst✝ : Semiring R
p q r : R[X]
pm : natDegree p ≤ m
qn : natDegree q ≤ n
hm : natDegree p < m
hn : natDegree q < n
⊢ coeff (p * q) (m + n) = 0
Theorem: DirectedOn.disjoint_sSup_right
File: Mathlib/Order/CompactlyGenerated.lean

tactic: simp_rw [disjoint_iff, h.inf_sSup_eq, iSup_eq_bot]
state_before: ι : Sort ?u.97615
α : Type u_1
inst✝² : CompleteLattice α
f : ι → α
inst✝¹ : CompleteLattice α
inst✝ : IsCompactlyGenerated α
a b : α
s : Set α
h : DirectedOn (fun x x_1 => x ≤ x_1) s
⊢ Disjoint a (sSup s) ↔ ∀ ⦃b : α⦄, b ∈ s → Disjoint a b
Theorem: CategoryTheory.Endofunctor.Algebra.iso_of_iso
File: Mathlib/CategoryTheory/Endofunctor/Algebra.lean

tactic: rw [IsIso.eq_comp_inv f.1, Category.assoc, ← f.h]
state_before: C : Type u
inst✝¹ : Category C
F : C ⥤ C
A A₀ A₁ A₂ : Algebra F
f✝ : A₀ ⟶ A₁
g : A₁ ⟶ A₂
f : A₀ ⟶ A₁
inst✝ : IsIso f.f
⊢ F.map (inv f.f) ≫ A₀.str = A₁.str ≫ inv f.f

tactic: simp
state_before: C : Type u
inst✝¹ : Category C
F : C ⥤ C
A A₀ A₁ A₂ : Algebra F
f✝ : A₀ ⟶ A₁
g : A₁ ⟶ A₂
f : A₀ ⟶ A₁
inst✝ : IsIso f.f
⊢ F.map (inv f.f) ≫ F.map f.f ≫ A₁.str = A₁.str

tactic: aesop_cat
state_before: C : Type u
inst✝¹ : Category C
F : C ⥤ C
A A₀ A₁ A₂ : Algebra F
f✝ : A₀ ⟶ A₁
g : A₁ ⟶ A₂
f : A₀ ⟶ A₁
inst✝ : IsIso f.f
⊢ f ≫ Hom.mk (inv f.f) = 𝟙 A₀

tactic: aesop_cat
state_before: C : Type u
inst✝¹ : Category C
F : C ⥤ C
A A₀ A₁ A₂ : Algebra F
f✝ : A₀ ⟶ A₁
g : A₁ ⟶ A₂
f : A₀ ⟶ A₁
inst✝ : IsIso f.f
⊢ Hom.mk (inv f.f) ≫ f = 𝟙 A₁
Theorem: Finset.Ioi_disjUnion_Iio
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: ext
state_before: ι : Type ?u.167907
α : Type u_1
inst✝³ : LinearOrder α
inst✝² : Fintype α
inst✝¹ : LocallyFiniteOrderTop α
inst✝ : LocallyFiniteOrderBot α
a : α
⊢ disjUnion (Ioi a) (Iio a) (_ : Disjoint (Ioi a) (Iio a)) = {a}ᶜ

tactic: simp [eq_comm]
state_before: case a
ι : Type ?u.167907
α : Type u_1
inst✝³ : LinearOrder α
inst✝² : Fintype α
inst✝¹ : LocallyFiniteOrderTop α
inst✝ : LocallyFiniteOrderBot α
a a✝ : α
⊢ a✝ ∈ disjUnion (Ioi a) (Iio a) (_ : Disjoint (Ioi a) (Iio a)) ↔ a✝ ∈ {a}ᶜ
Theorem: mul_inv_lt_one_iff
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [one_mul]
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LT α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c : α
⊢ b < 1 * a ↔ b < a
Theorem: Int.ldiff_bit
File: Mathlib/Data/Int/Bitwise.lean

tactic: rw [← bitwise_diff, bitwise_bit]
state_before: a : Bool
m : ℤ
b : Bool
n : ℤ
⊢ ldiff' (bit a m) (bit b n) = bit (a && !b) (ldiff' m n)
Theorem: List.length_scanl
File: Mathlib/Data/List/Basic.lean

tactic: rw [scanl, length_cons, length_cons, ←succ_eq_add_one, congr_arg succ]
state_before: ι : Type ?u.238764
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : β → α → β
b : β
a✝ : α
l✝ : List α
a : β
x : α
l : List α
⊢ length (scanl f a (x :: l)) = length (x :: l) + 1

tactic: exact length_scanl _ _
state_before: ι : Type ?u.238764
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : β → α → β
b : β
a✝ : α
l✝ : List α
a : β
x : α
l : List α
⊢ length (scanl f (f a x) l) = length l + 1
Theorem: Filter.generate_neBot_iff
File: Mathlib/Order/Filter/Bases.lean

tactic: simp only [← and_imp, and_comm]
state_before: α : Type u_1
β : Type ?u.21459
γ : Type ?u.21462
ι : Sort ?u.21465
ι' : Sort ?u.21468
l l' : Filter α
p : ι → Prop
s✝ : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
s : Set (Set α)
⊢ (∀ {i : Set (Set α)}, Set.Finite i ∧ i ⊆ s → Set.Nonempty (⋂₀ i)) ↔
    ∀ (t : Set (Set α)), t ⊆ s → Set.Finite t → Set.Nonempty (⋂₀ t)
Theorem: Finset.sup_id_eq_sSup
File: Mathlib/Data/Finset/Lattice.lean

tactic: simp [sSup_eq_iSup, sup_eq_iSup]
state_before: F : Type ?u.88438
α : Type u_1
β : Type ?u.88444
γ : Type ?u.88447
ι : Type ?u.88450
κ : Type ?u.88453
inst✝ : CompleteLattice α
s : Finset α
⊢ sup s id = sSup ↑s
Theorem: IsSelfAdjoint.sub
File: Mathlib/Algebra/Star/SelfAdjoint.lean

tactic: simp only [isSelfAdjoint_iff, star_sub, hx.star_eq, hy.star_eq]
state_before: R : Type u_1
A : Type ?u.10014
inst✝¹ : AddGroup R
inst✝ : StarAddMonoid R
x y : R
hx : IsSelfAdjoint x
hy : IsSelfAdjoint y
⊢ IsSelfAdjoint (x - y)
Theorem: ZMod.ringHom_eq_of_ker_eq
File: Mathlib/Data/ZMod/Basic.lean

tactic: have := f.liftOfRightInverse_comp _ (ZMod.ringHom_rightInverse f) ⟨g, le_of_eq h⟩
state_before: n : ℕ
R : Type u_1
inst✝ : CommRing R
f g : R →+* ZMod n
h : RingHom.ker f = RingHom.ker g
⊢ f = g

tactic: rw [Subtype.coe_mk] at this
state_before: n : ℕ
R : Type u_1
inst✝ : CommRing R
f g : R →+* ZMod n
h : RingHom.ker f = RingHom.ker g
this :
  RingHom.comp
      (↑(RingHom.liftOfRightInverse f cast (_ : Function.RightInverse cast ↑f))
        { val := g, property := (_ : RingHom.ker f ≤ RingHom.ker g) })
      f =
    ↑{ val := g, property := (_ : RingHom.ker f ≤ RingHom.ker g) }
⊢ f = g

tactic: rw [← this, RingHom.ext_zmod (f.liftOfRightInverse _ _ ⟨g, _⟩) _, RingHom.id_comp]
state_before: n : ℕ
R : Type u_1
inst✝ : CommRing R
f g : R →+* ZMod n
h : RingHom.ker f = RingHom.ker g
this :
  RingHom.comp
      (↑(RingHom.liftOfRightInverse f cast (_ : Function.RightInverse cast ↑f))
        { val := g, property := (_ : RingHom.ker f ≤ RingHom.ker g) })
      f =
    g
⊢ f = g
Theorem: Int.squarefree_natAbs
File: Mathlib/Algebra/Squarefree.lean

tactic: simp_rw [Squarefree, natAbs_surjective.forall, ← natAbs_mul, natAbs_dvd_natAbs,
  isUnit_iff_natAbs_eq, Nat.isUnit_iff]
state_before: R : Type ?u.124635
n : ℤ
⊢ Squarefree (natAbs n) ↔ Squarefree n
Theorem: Module.End.mem_spectrum_of_hasEigenvalue
File: Mathlib/LinearAlgebra/Eigenspace/Basic.lean

tactic: refine' spectrum.mem_iff.mpr fun h_unit => _
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ : R
hμ : HasEigenvalue f μ
⊢ μ ∈ spectrum R f

tactic: set f' := LinearMap.GeneralLinearGroup.toLinearEquiv h_unit.unit
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ : R
hμ : HasEigenvalue f μ
h_unit : IsUnit (↑(algebraMap R (End R M)) μ - f)
⊢ False

tactic: rcases hμ.exists_hasEigenvector with ⟨v, hv⟩
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ : R
hμ : HasEigenvalue f μ
h_unit : IsUnit (↑(algebraMap R (End R M)) μ - f)
f' : M ≃ₗ[R] M := LinearMap.GeneralLinearGroup.toLinearEquiv (IsUnit.unit h_unit)
⊢ False

tactic: refine' hv.2 ((LinearMap.ker_eq_bot'.mp f'.ker) v (_ : μ • v - f v = 0))
state_before: case intro
K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ : R
hμ : HasEigenvalue f μ
h_unit : IsUnit (↑(algebraMap R (End R M)) μ - f)
f' : M ≃ₗ[R] M := LinearMap.GeneralLinearGroup.toLinearEquiv (IsUnit.unit h_unit)
v : M
hv : HasEigenvector f μ v
⊢ False

tactic: rw [hv.apply_eq_smul, sub_self]
state_before: case intro
K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ : R
hμ : HasEigenvalue f μ
h_unit : IsUnit (↑(algebraMap R (End R M)) μ - f)
f' : M ≃ₗ[R] M := LinearMap.GeneralLinearGroup.toLinearEquiv (IsUnit.unit h_unit)
v : M
hv : HasEigenvector f μ v
⊢ μ • v - ↑f v = 0
Theorem: List.map_filter
File: Std/Data/List/Lemmas.lean

tactic: rw [← filterMap_eq_map, filter_filterMap, filterMap_filter]
state_before: β : Type u_1
α : Type u_2
p : α → Bool
f : β → α
l : List β
⊢ filter p (map f l) = map f (filter (p ∘ f) l)

tactic: rfl
state_before: β : Type u_1
α : Type u_2
p : α → Bool
f : β → α
l : List β
⊢ filterMap (fun x => Option.filter p ((some ∘ f) x)) l =
    filterMap (fun x => if (p ∘ f) x = true then (some ∘ f) x else none) l
Theorem: MulActionHom.id_comp
File: Mathlib/Algebra/Hom/GroupAction.lean

tactic: rw [comp_apply, id_apply]
state_before: M' : Type u_1
X : Type u_2
inst✝²³ : SMul M' X
Y : Type u_3
inst✝²² : SMul M' Y
Z : Type ?u.46874
inst✝²¹ : SMul M' Z
M : Type ?u.46881
inst✝²⁰ : Monoid M
A : Type ?u.46887
inst✝¹⁹ : AddMonoid A
inst✝¹⁸ : DistribMulAction M A
A' : Type ?u.46915
inst✝¹⁷ : AddGroup A'
inst✝¹⁶ : DistribMulAction M A'
B : Type ?u.47191
inst✝¹⁵ : AddMonoid B
inst✝¹⁴ : DistribMulAction M B
B' : Type ?u.47217
inst✝¹³ : AddGroup B'
inst✝¹² : DistribMulAction M B'
C : Type ?u.47493
inst✝¹¹ : AddMonoid C
inst✝¹⁰ : DistribMulAction M C
R : Type ?u.47519
inst✝⁹ : Semiring R
inst✝⁸ : MulSemiringAction M R
R' : Type ?u.47546
inst✝⁷ : Ring R'
inst✝⁶ : MulSemiringAction M R'
S : Type ?u.47742
inst✝⁵ : Semiring S
inst✝⁴ : MulSemiringAction M S
S' : Type ?u.47769
inst✝³ : Ring S'
inst✝² : MulSemiringAction M S'
T : Type ?u.47965
inst✝¹ : Semiring T
inst✝ : MulSemiringAction M T
f : X →[M'] Y
x : X
⊢ ↑(comp (MulActionHom.id M') f) x = ↑f x
Theorem: Dfinsupp.support_update
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: ext j
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝² : (i : ι) → Zero (β i)
inst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
f : Π₀ (i : ι), β i
i : ι
b : β i
inst✝ : Decidable (b = 0)
⊢ support (update i f b) = if b = 0 then support (erase i f) else insert i (support f)

tactic: split_ifs with hb
state_before: case a
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝² : (i : ι) → Zero (β i)
inst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
f : Π₀ (i : ι), β i
i : ι
b : β i
inst✝ : Decidable (b = 0)
j : ι
⊢ j ∈ support (update i f b) ↔ j ∈ if b = 0 then support (erase i f) else insert i (support f)

tactic: subst hb
state_before: case a.inl
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝² : (i : ι) → Zero (β i)
inst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
f : Π₀ (i : ι), β i
i : ι
b : β i
inst✝ : Decidable (b = 0)
j : ι
hb : b = 0
⊢ j ∈ support (update i f b) ↔ j ∈ support (erase i f)

tactic: simp [update_eq_erase, support_erase]
state_before: case a.inl
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝² : (i : ι) → Zero (β i)
inst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
f : Π₀ (i : ι), β i
i j : ι
inst✝ : Decidable (0 = 0)
⊢ j ∈ support (update i f 0) ↔ j ∈ support (erase i f)

tactic: rw [support_update_ne_zero f _ hb]
state_before: case a.inr
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝² : (i : ι) → Zero (β i)
inst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
f : Π₀ (i : ι), β i
i : ι
b : β i
inst✝ : Decidable (b = 0)
j : ι
hb : ¬b = 0
⊢ j ∈ support (update i f b) ↔ j ∈ insert i (support f)
Theorem: Int.emod_lt_of_pos
File: Std/Data/Int/DivMod.lean

tactic: simp [emod, Int.subNatNat_eq_coe]
state_before: a b : Int
m n : Nat
H : 0 < ↑(succ n)
⊢ -[m+1] % ↑(succ n) < ↑(succ n)

tactic: exact Int.sub_lt_self _ (ofNat_lt.2 <| Nat.succ_pos _)
state_before: a b : Int
m n : Nat
H : 0 < ↑(succ n)
⊢ -[m+1] % ↑(succ n) < ↑(succ n)
Theorem: Nat.mul_left_eq_self_iff
File: Mathlib/Data/Nat/Basic.lean

tactic: rw [mul_comm, Nat.mul_right_eq_self_iff hb]
state_before: m n k a b : ℕ
hb : 0 < b
⊢ a * b = b ↔ a = 1
Theorem: Metric.toInductiveLimit_commute
File: Mathlib/Topology/MetricSpace/Gluing.lean

tactic: let _ := inductivePremetric I
state_before: X : ℕ → Type u
inst✝ : (n : ℕ) → MetricSpace (X n)
f : (n : ℕ) → X n → X (n + 1)
I : ∀ (n : ℕ), Isometry (f n)
n : ℕ
⊢ toInductiveLimit I (succ n) ∘ f n = toInductiveLimit I n

tactic: funext x
state_before: X : ℕ → Type u
inst✝ : (n : ℕ) → MetricSpace (X n)
f : (n : ℕ) → X n → X (n + 1)
I : ∀ (n : ℕ), Isometry (f n)
n : ℕ
x✝ : PseudoMetricSpace ((n : ℕ) × X n) := inductivePremetric I
⊢ toInductiveLimit I (succ n) ∘ f n = toInductiveLimit I n

tactic: simp only [comp, toInductiveLimit]
state_before: case h
X : ℕ → Type u
inst✝ : (n : ℕ) → MetricSpace (X n)
f : (n : ℕ) → X n → X (n + 1)
I : ∀ (n : ℕ), Isometry (f n)
n : ℕ
x✝ : PseudoMetricSpace ((n : ℕ) × X n) := inductivePremetric I
x : X n
⊢ (toInductiveLimit I (succ n) ∘ f n) x = toInductiveLimit I n x

tactic: refine' UniformSpace.SeparationQuotient.mk_eq_mk.2 (Metric.inseparable_iff.2 _)
state_before: case h
X : ℕ → Type u
inst✝ : (n : ℕ) → MetricSpace (X n)
f : (n : ℕ) → X n → X (n + 1)
I : ∀ (n : ℕ), Isometry (f n)
n : ℕ
x✝ : PseudoMetricSpace ((n : ℕ) × X n) := inductivePremetric I
x : X n
⊢ Quotient.mk'' { fst := succ n, snd := f n x } = Quotient.mk'' { fst := n, snd := x }

tactic: show inductiveLimitDist f ⟨n.succ, f n x⟩ ⟨n, x⟩ = 0
state_before: case h
X : ℕ → Type u
inst✝ : (n : ℕ) → MetricSpace (X n)
f : (n : ℕ) → X n → X (n + 1)
I : ∀ (n : ℕ), Isometry (f n)
n : ℕ
x✝ : PseudoMetricSpace ((n : ℕ) × X n) := inductivePremetric I
x : X n
⊢ dist { fst := succ n, snd := f n x } { fst := n, snd := x } = 0

tactic: rw [inductiveLimitDist_eq_dist I ⟨n.succ, f n x⟩ ⟨n, x⟩ n.succ, leRecOn_self,
  leRecOn_succ, leRecOn_self, dist_self]
state_before: case h
X : ℕ → Type u
inst✝ : (n : ℕ) → MetricSpace (X n)
f : (n : ℕ) → X n → X (n + 1)
I : ∀ (n : ℕ), Isometry (f n)
n : ℕ
x✝ : PseudoMetricSpace ((n : ℕ) × X n) := inductivePremetric I
x : X n
⊢ inductiveLimitDist f { fst := succ n, snd := f n x } { fst := n, snd := x } = 0

tactic: exacts [le_rfl, le_succ _, le_rfl]
state_before: X : ℕ → Type u
inst✝ : (n : ℕ) → MetricSpace (X n)
f : (n : ℕ) → X n → X (n + 1)
I : ∀ (n : ℕ), Isometry (f n)
n : ℕ
x✝ : PseudoMetricSpace ((n : ℕ) × X n) := inductivePremetric I
x : X n
⊢ { fst := n, snd := x }.fst ≤ { fst := n, snd := x }.fst

case h.h2
X : ℕ → Type u
inst✝ : (n : ℕ) → MetricSpace (X n)
f : (n : ℕ) → X n → X (n + 1)
I : ∀ (n : ℕ), Isometry (f n)
n : ℕ
x✝ : PseudoMetricSpace ((n : ℕ) × X n) := inductivePremetric I
x : X n
⊢ { fst := n, snd := x }.fst ≤ n + 1

X : ℕ → Type u
inst✝ : (n : ℕ) → MetricSpace (X n)
f : (n : ℕ) → X n → X (n + 1)
I : ∀ (n : ℕ), Isometry (f n)
n : ℕ
x✝ : PseudoMetricSpace ((n : ℕ) × X n) := inductivePremetric I
x : X n
⊢ { fst := succ n, snd := f n x }.fst ≤ { fst := succ n, snd := f n x }.fst
Theorem: MeasureTheory.measure_mono_ae
File: Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean

tactic: rw [union_diff_self, Set.union_comm]
state_before: α : Type u_1
β : Type ?u.137021
γ : Type ?u.137024
δ : Type ?u.137027
ι : Type ?u.137030
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
H : s ≤ᵐ[μ] t
⊢ ↑↑μ (s ∪ t) = ↑↑μ (t ∪ s \ t)

tactic: rw [ae_le_set.1 H, add_zero]
state_before: α : Type u_1
β : Type ?u.137021
γ : Type ?u.137024
δ : Type ?u.137027
ι : Type ?u.137030
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
H : s ≤ᵐ[μ] t
⊢ ↑↑μ t + ↑↑μ (s \ t) = ↑↑μ t
Theorem: Finset.filter_inter_filter_neg_eq
File: Mathlib/Data/Finset/Basic.lean

tactic: simpa using (disjoint_filter_filter_neg s t p).eq_bot
state_before: α : Type u_1
β : Type ?u.417033
γ : Type ?u.417036
p q : α → Prop
inst✝² : DecidablePred p
inst✝¹ : DecidablePred q
inst✝ : DecidableEq α
s t : Finset α
⊢ filter p s ∩ filter (fun a => ¬p a) t = ∅
Theorem: ZNum.div_to_int
File: Mathlib/Data/Num/Lemmas.lean

tactic: simp [Int.ediv_zero]
state_before: ⊢ ↑(0 / 0) = ↑0 / ↑0

tactic: rw [← Num.to_nat_to_int]
state_before: n d : PosNum
⊢ ↑(PosNum.div' n d) = ↑(pos n) / ↑(pos d)

tactic: simp
state_before: n d : PosNum
⊢ ↑↑(PosNum.div' n d) = ↑(pos n) / ↑(pos d)

tactic: rw [← Num.to_nat_to_int]
state_before: n d : PosNum
⊢ -↑(PosNum.div' n d) = ↑(pos n) / ↑(neg d)

tactic: simp
state_before: n d : PosNum
⊢ -↑↑(PosNum.div' n d) = ↑(pos n) / ↑(neg d)

tactic: rw [n.to_int_eq_succ_pred, d.to_int_eq_succ_pred, ← PosNum.to_nat_to_int, Num.succ'_to_nat,
  Num.div_to_nat]
state_before: n d : PosNum
⊢ -↑(Num.succ' (PosNum.pred' n / Num.pos d)) = -↑n / ↑d

tactic: change -[n.pred' / ↑d+1] = -[n.pred' / (d.pred' + 1)+1]
state_before: n d : PosNum
⊢ -↑(↑(PosNum.pred' n) / ↑(Num.pos d) + 1) = -(↑↑(PosNum.pred' n) + 1) / (↑↑(PosNum.pred' d) + 1)

tactic: rw [d.to_nat_eq_succ_pred]
state_before: n d : PosNum
⊢ -[↑(PosNum.pred' n) / ↑d+1] = -[↑(PosNum.pred' n) / (↑(PosNum.pred' d) + 1)+1]

tactic: rw [n.to_int_eq_succ_pred, d.to_int_eq_succ_pred, ← PosNum.to_nat_to_int, Num.succ'_to_nat,
  Num.div_to_nat]
state_before: n d : PosNum
⊢ ↑(Num.succ' (PosNum.pred' n / Num.pos d)) = -↑n / -↑d

tactic: change (Nat.succ (_ / d) : ℤ) = Nat.succ (n.pred' / (d.pred' + 1))
state_before: n d : PosNum
⊢ ↑(↑(PosNum.pred' n) / ↑(Num.pos d) + 1) = -(↑↑(PosNum.pred' n) + 1) / -(↑↑(PosNum.pred' d) + 1)

tactic: rw [d.to_nat_eq_succ_pred]
state_before: n d : PosNum
⊢ ↑(Nat.succ (↑(PosNum.pred' n) / ↑d)) = ↑(Nat.succ (↑(PosNum.pred' n) / (↑(PosNum.pred' d) + 1)))
Theorem: isIntegral_algEquiv
File: Mathlib/RingTheory/IntegralClosure.lean

tactic: simpa using map_isIntegral f.symm.toAlgHom h
state_before: R : Type u_3
A✝ : Type ?u.168448
B✝ : Type ?u.168451
S : Type ?u.168454
inst✝⁹ : CommRing R
inst✝⁸ : CommRing A✝
inst✝⁷ : CommRing B✝
inst✝⁶ : CommRing S
inst✝⁵ : Algebra R A✝
inst✝⁴ : Algebra R B✝
f✝ : R →+* S
A : Type u_1
B : Type u_2
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : A ≃ₐ[R] B
x : A
h : IsIntegral R (↑f x)
⊢ IsIntegral R x
Theorem: Finset.powersetLen_empty
File: Mathlib/Data/Finset/Powerset.lean

tactic: rw [card_powersetLen, Nat.choose_eq_zero_of_lt h]
state_before: α : Type u_1
s✝ t : Finset α
n : ℕ
s : Finset α
h : card s < n
⊢ card (powersetLen n s) = 0
Theorem: edist_eq_coe_nnnorm_div
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: rw [edist_dist, dist_eq_norm_div, ofReal_norm_eq_coe_nnnorm']
state_before: 𝓕 : Type ?u.328683
𝕜 : Type ?u.328686
α : Type ?u.328689
ι : Type ?u.328692
κ : Type ?u.328695
E : Type u_1
F : Type ?u.328701
G : Type ?u.328704
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a✝ a₁ a₂ b✝ b₁ b₂ : E
r r₁ r₂ : ℝ
a b : E
⊢ edist a b = ↑‖a / b‖₊
Theorem: String.Iterator.ValidFor.out'
File: Std/Data/String/Lemmas.lean

tactic: simp [List.reverseAux_eq]
state_before: l r : List Char
⊢ { s := { data := List.reverseAux l r }, i := { byteIdx := utf8Len l } } =
    { s := { data := List.reverse l ++ r }, i := { byteIdx := utf8Len (List.reverse l) } }
Theorem: CircleDeg1Lift.units_apply_inv_apply
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: simp only [← mul_apply, f.mul_inv, coe_one, id]
state_before: f✝ g : CircleDeg1Lift
f : CircleDeg1Liftˣ
x : ℝ
⊢ ↑↑f (↑↑f⁻¹ x) = x
Theorem: EuclideanGeometry.dist_sq_eq_dist_sq_add_dist_sq_iff_angle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean

tactic: erw [dist_comm p3 p2, dist_eq_norm_vsub V p1 p3, dist_eq_norm_vsub V p1 p2,
  dist_eq_norm_vsub V p2 p3, ← norm_sub_sq_eq_norm_sq_add_norm_sq_iff_angle_eq_pi_div_two,
  vsub_sub_vsub_cancel_right p1, ← neg_vsub_eq_vsub_rev p2 p3, norm_neg]
state_before: V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p1 p2 p3 : P
⊢ dist p1 p3 * dist p1 p3 = dist p1 p2 * dist p1 p2 + dist p3 p2 * dist p3 p2 ↔ ∠ p1 p2 p3 = π / 2
Theorem: Ordinal.isLimit_of_mem_frontier
File: Mathlib/SetTheory/Ordinal/Topology.lean

tactic: simp only [frontier_eq_closure_inter_closure, Set.mem_inter_iff, mem_closure_iff] at ha
state_before: s : Set Ordinal
a : Ordinal
ha : a ∈ frontier s
⊢ IsLimit a

tactic: by_contra h
state_before: s : Set Ordinal
a : Ordinal
ha :
  (∀ (o : Set Ordinal), IsOpen o → a ∈ o → Set.Nonempty (o ∩ s)) ∧
    ∀ (o : Set Ordinal), IsOpen o → a ∈ o → Set.Nonempty (o ∩ sᶜ)
⊢ IsLimit a

tactic: rw [← isOpen_singleton_iff] at h
state_before: s : Set Ordinal
a : Ordinal
ha :
  (∀ (o : Set Ordinal), IsOpen o → a ∈ o → Set.Nonempty (o ∩ s)) ∧
    ∀ (o : Set Ordinal), IsOpen o → a ∈ o → Set.Nonempty (o ∩ sᶜ)
h : ¬IsLimit a
⊢ False

tactic: rcases ha.1 _ h rfl with ⟨b, hb, hb'⟩
state_before: s : Set Ordinal
a : Ordinal
ha :
  (∀ (o : Set Ordinal), IsOpen o → a ∈ o → Set.Nonempty (o ∩ s)) ∧
    ∀ (o : Set Ordinal), IsOpen o → a ∈ o → Set.Nonempty (o ∩ sᶜ)
h : IsOpen {a}
⊢ False

tactic: rcases ha.2 _ h rfl with ⟨c, hc, hc'⟩
state_before: case intro.intro
s : Set Ordinal
a : Ordinal
ha :
  (∀ (o : Set Ordinal), IsOpen o → a ∈ o → Set.Nonempty (o ∩ s)) ∧
    ∀ (o : Set Ordinal), IsOpen o → a ∈ o → Set.Nonempty (o ∩ sᶜ)
h : IsOpen {a}
b : Ordinal
hb : b ∈ {a}
hb' : b ∈ s
⊢ False

tactic: rw [Set.mem_singleton_iff] at *
state_before: case intro.intro.intro.intro
s : Set Ordinal
a : Ordinal
ha :
  (∀ (o : Set Ordinal), IsOpen o → a ∈ o → Set.Nonempty (o ∩ s)) ∧
    ∀ (o : Set Ordinal), IsOpen o → a ∈ o → Set.Nonempty (o ∩ sᶜ)
h : IsOpen {a}
b : Ordinal
hb : b ∈ {a}
hb' : b ∈ s
c : Ordinal
hc : c ∈ {a}
hc' : c ∈ sᶜ
⊢ False

tactic: subst hb
state_before: case intro.intro.intro.intro
s : Set Ordinal
a : Ordinal
ha :
  (∀ (o : Set Ordinal), IsOpen o → a ∈ o → Set.Nonempty (o ∩ s)) ∧
    ∀ (o : Set Ordinal), IsOpen o → a ∈ o → Set.Nonempty (o ∩ sᶜ)
h : IsOpen {a}
b : Ordinal
hb : b = a
hb' : b ∈ s
c : Ordinal
hc : c = a
hc' : c ∈ sᶜ
⊢ False

tactic: subst hc
state_before: case intro.intro.intro.intro
s : Set Ordinal
b : Ordinal
hb' : b ∈ s
c : Ordinal
hc' : c ∈ sᶜ
ha :
  (∀ (o : Set Ordinal), IsOpen o → b ∈ o → Set.Nonempty (o ∩ s)) ∧
    ∀ (o : Set Ordinal), IsOpen o → b ∈ o → Set.Nonempty (o ∩ sᶜ)
h : IsOpen {b}
hc : c = b
⊢ False

tactic: exact hc' hb'
state_before: case intro.intro.intro.intro
s : Set Ordinal
c : Ordinal
hc' : c ∈ sᶜ
hb' : c ∈ s
ha :
  (∀ (o : Set Ordinal), IsOpen o → c ∈ o → Set.Nonempty (o ∩ s)) ∧
    ∀ (o : Set Ordinal), IsOpen o → c ∈ o → Set.Nonempty (o ∩ sᶜ)
h : IsOpen {c}
⊢ False