tasksource/leandojo huggingface dataset:
Theorem: nhds_swap
File: Mathlib/Topology/Constructions.lean

tactic: rw [nhds_prod_eq, Filter.prod_comm, nhds_prod_eq]
state_before: α : Type u
β : Type v
γ : Type ?u.39611
δ : Type ?u.39614
ε : Type ?u.39617
ζ : Type ?u.39620
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : TopologicalSpace ε
inst✝ : TopologicalSpace ζ
a : α
b : β
⊢ 𝓝 (a, b) = map Prod.swap (𝓝 (b, a))

tactic: rfl
state_before: α : Type u
β : Type v
γ : Type ?u.39611
δ : Type ?u.39614
ε : Type ?u.39617
ζ : Type ?u.39620
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : TopologicalSpace ε
inst✝ : TopologicalSpace ζ
a : α
b : β
⊢ map (fun p => (p.snd, p.fst)) (𝓝 b ×ˢ 𝓝 a) = map Prod.swap (𝓝 b ×ˢ 𝓝 a)
Theorem: CategoryTheory.Functor.image_preimage
File: Mathlib/CategoryTheory/Functor/FullyFaithful.lean

tactic: unfold preimage
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
X✝ Y✝ : C
F : C ⥤ D
inst✝ : Full F
X Y : C
f : F.obj X ⟶ F.obj Y
⊢ F.map (F.preimage f) = f

tactic: aesop_cat
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
X✝ Y✝ : C
F : C ⥤ D
inst✝ : Full F
X Y : C
f : F.obj X ⟶ F.obj Y
⊢ F.map (Full.preimage f) = f
Theorem: Real.Angle.coe_pi_add_coe_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [← two_nsmul, two_nsmul_coe_pi]
state_before: ⊢ ↑π + ↑π = 0
Theorem: Finset.insert_subset
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [subset_iff, mem_insert, forall_eq, or_imp, forall_and]
state_before: α : Type u_1
β : Type ?u.112523
γ : Type ?u.112526
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
⊢ insert a s ⊆ t ↔ a ∈ t ∧ s ⊆ t
Theorem: Nat.map_div_right_divisors
File: Mathlib/NumberTheory/Divisors.lean

tactic: ext ⟨d, nd⟩
state_before: n : ℕ
⊢ map
      { toFun := fun d => (d, n / d),
        inj' :=
          (_ :
            ∀ (p₁ p₂ : ℕ),
              (fun d => (d, n / d)) p₁ = (fun d => (d, n / d)) p₂ →
                ((fun d => (d, n / d)) p₁).fst = ((fun d => (d, n / d)) p₂).fst) }
      (divisors n) =
    divisorsAntidiagonal n

tactic: simp only [mem_map, mem_divisorsAntidiagonal, Function.Embedding.coeFn_mk, mem_divisors,
  Prod.ext_iff, exists_prop, and_left_comm, exists_eq_left]
state_before: case a.mk
n d nd : ℕ
⊢ (d, nd) ∈
      map
        { toFun := fun d => (d, n / d),
          inj' :=
            (_ :
              ∀ (p₁ p₂ : ℕ),
                (fun d => (d, n / d)) p₁ = (fun d => (d, n / d)) p₂ →
                  ((fun d => (d, n / d)) p₁).fst = ((fun d => (d, n / d)) p₂).fst) }
        (divisors n) ↔
    (d, nd) ∈ divisorsAntidiagonal n

tactic: constructor
state_before: case a.mk
n d nd : ℕ
⊢ (d ∣ n ∧ n ≠ 0) ∧ n / d = nd ↔ d * nd = n ∧ n ≠ 0

tactic: rintro ⟨⟨⟨k, rfl⟩, hn⟩, rfl⟩
state_before: case a.mk.mp
n d nd : ℕ
⊢ (d ∣ n ∧ n ≠ 0) ∧ n / d = nd → d * nd = n ∧ n ≠ 0

tactic: rw [Nat.mul_div_cancel_left _ (left_ne_zero_of_mul hn).bot_lt]
state_before: case a.mk.mp.intro.intro.intro
d k : ℕ
hn : d * k ≠ 0
⊢ d * (d * k / d) = d * k ∧ d * k ≠ 0

tactic: exact ⟨rfl, hn⟩
state_before: case a.mk.mp.intro.intro.intro
d k : ℕ
hn : d * k ≠ 0
⊢ d * k = d * k ∧ d * k ≠ 0

tactic: rintro ⟨rfl, hn⟩
state_before: case a.mk.mpr
n d nd : ℕ
⊢ d * nd = n ∧ n ≠ 0 → (d ∣ n ∧ n ≠ 0) ∧ n / d = nd

tactic: exact ⟨⟨dvd_mul_right _ _, hn⟩, Nat.mul_div_cancel_left _ (left_ne_zero_of_mul hn).bot_lt⟩
state_before: case a.mk.mpr.intro
d nd : ℕ
hn : d * nd ≠ 0
⊢ (d ∣ d * nd ∧ d * nd ≠ 0) ∧ d * nd / d = nd
Theorem: Real.Icc_mem_vitaliFamily_at_right
File: Mathlib/MeasureTheory/Covering/OneDim.lean

tactic: rw [Icc_eq_closedBall]
state_before: x y : ℝ
hxy : x < y
⊢ Icc x y ∈ VitaliFamily.setsAt (vitaliFamily volume 1) x

tactic: refine' closedBall_mem_vitaliFamily_of_dist_le_mul _ _ (by linarith)
state_before: x y : ℝ
hxy : x < y
⊢ Metric.closedBall ((x + y) / 2) ((y - x) / 2) ∈ VitaliFamily.setsAt (vitaliFamily volume 1) x

tactic: rw [dist_comm, Real.dist_eq, abs_of_nonneg] <;> linarith
state_before: x y : ℝ
hxy : x < y
⊢ dist x ((x + y) / 2) ≤ 1 * ((y - x) / 2)

tactic: linarith
state_before: x y : ℝ
hxy : x < y
⊢ 0 < (y - x) / 2
Theorem: real_inner_add_add_self
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: have : ⟪y, x⟫_ℝ = ⟪x, y⟫_ℝ := by rw [← inner_conj_symm]; rfl
state_before: 𝕜 : Type ?u.1806744
E : Type ?u.1806747
F : Type u_1
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : F
⊢ inner (x + y) (x + y) = inner x x + 2 * inner x y + inner y y

tactic: simp only [inner_add_add_self, this, add_left_inj]
state_before: 𝕜 : Type ?u.1806744
E : Type ?u.1806747
F : Type u_1
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : F
this : inner y x = inner x y
⊢ inner (x + y) (x + y) = inner x x + 2 * inner x y + inner y y

tactic: ring
state_before: 𝕜 : Type ?u.1806744
E : Type ?u.1806747
F : Type u_1
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : F
this : inner y x = inner x y
⊢ inner x x + inner x y + inner x y = inner x x + 2 * inner x y

tactic: rw [← inner_conj_symm]
state_before: 𝕜 : Type ?u.1806744
E : Type ?u.1806747
F : Type u_1
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : F
⊢ inner y x = inner x y

tactic: rfl
state_before: 𝕜 : Type ?u.1806744
E : Type ?u.1806747
F : Type u_1
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : F
⊢ ↑(starRingEnd ℝ) (inner x y) = inner x y
Theorem: Right.one_le_inv_iff
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [← mul_le_mul_iff_right a]
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c : α
⊢ 1 ≤ a⁻¹ ↔ a ≤ 1

tactic: simp
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c : α
⊢ 1 * a ≤ a⁻¹ * a ↔ a ≤ 1
Theorem: Finset.memberSubfamily_nonMemberSubfamily
File: Mathlib/Combinatorics/SetFamily/Compression/Down.lean

tactic: ext
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
⊢ memberSubfamily a (nonMemberSubfamily a 𝒜) = ∅

tactic: simp
state_before: case a
α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
a✝ : Finset α
⊢ a✝ ∈ memberSubfamily a (nonMemberSubfamily a 𝒜) ↔ a✝ ∈ ∅
Theorem: CategoryTheory.Limits.cokernelIsoOfEq_inv_comp_desc
File: Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean

tactic: simp [← h, he]
state_before: C : Type u
inst✝⁴ : Category C
inst✝³ : HasZeroMorphisms C
X Y : C
f✝ : X ⟶ Y
inst✝² : HasCokernel f✝
Z : C
f g : X ⟶ Y
inst✝¹ : HasCokernel f
inst✝ : HasCokernel g
h : f = g
e : Y ⟶ Z
he : f ≫ e = 0
⊢ g ≫ e = 0

tactic: cases h
state_before: C : Type u
inst✝⁴ : Category C
inst✝³ : HasZeroMorphisms C
X Y : C
f✝ : X ⟶ Y
inst✝² : HasCokernel f✝
Z : C
f g : X ⟶ Y
inst✝¹ : HasCokernel f
inst✝ : HasCokernel g
h : f = g
e : Y ⟶ Z
he : f ≫ e = 0
⊢ (cokernelIsoOfEq h).inv ≫ cokernel.desc f e he = cokernel.desc g e (_ : g ≫ e = 0)

tactic: simp
state_before: case refl
C : Type u
inst✝⁴ : Category C
inst✝³ : HasZeroMorphisms C
X Y : C
f✝ : X ⟶ Y
inst✝² : HasCokernel f✝
Z : C
f : X ⟶ Y
inst✝¹ : HasCokernel f
e : Y ⟶ Z
he : f ≫ e = 0
inst✝ : HasCokernel f
⊢ (cokernelIsoOfEq (_ : f = f)).inv ≫ cokernel.desc f e he = cokernel.desc f e (_ : f ≫ e = 0)
Theorem: Set.update_preimage_pi
File: Mathlib/Data/Set/Prod.lean

tactic: ext x
state_before: ι : Type u_1
α : ι → Type u_2
β : ι → Type ?u.163005
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
inst✝ : DecidableEq ι
f : (i : ι) → α i
hi : i ∈ s
hf : ∀ (j : ι), j ∈ s → j ≠ i → f j ∈ t j
⊢ update f i ⁻¹' pi s t = t i

tactic: refine' ⟨fun h => _, fun hx j hj => _⟩
state_before: case h
ι : Type u_1
α : ι → Type u_2
β : ι → Type ?u.163005
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
inst✝ : DecidableEq ι
f : (i : ι) → α i
hi : i ∈ s
hf : ∀ (j : ι), j ∈ s → j ≠ i → f j ∈ t j
x : α i
⊢ x ∈ update f i ⁻¹' pi s t ↔ x ∈ t i

tactic: convert h i hi
state_before: case h.refine'_1
ι : Type u_1
α : ι → Type u_2
β : ι → Type ?u.163005
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
inst✝ : DecidableEq ι
f : (i : ι) → α i
hi : i ∈ s
hf : ∀ (j : ι), j ∈ s → j ≠ i → f j ∈ t j
x : α i
h : x ∈ update f i ⁻¹' pi s t
⊢ x ∈ t i

tactic: simp
state_before: case h.e'_4
ι : Type u_1
α : ι → Type u_2
β : ι → Type ?u.163005
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
inst✝ : DecidableEq ι
f : (i : ι) → α i
hi : i ∈ s
hf : ∀ (j : ι), j ∈ s → j ≠ i → f j ∈ t j
x : α i
h : x ∈ update f i ⁻¹' pi s t
⊢ x = update f i x i

tactic: obtain rfl | h := eq_or_ne j i
state_before: case h.refine'_2
ι : Type u_1
α : ι → Type u_2
β : ι → Type ?u.163005
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
inst✝ : DecidableEq ι
f : (i : ι) → α i
hi : i ∈ s
hf : ∀ (j : ι), j ∈ s → j ≠ i → f j ∈ t j
x : α i
hx : x ∈ t i
j : ι
hj : j ∈ s
⊢ update f i x j ∈ t j

tactic: simpa
state_before: case h.refine'_2.inl
ι : Type u_1
α : ι → Type u_2
β : ι → Type ?u.163005
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
inst✝ : DecidableEq ι
f : (i : ι) → α i
j : ι
hj hi : j ∈ s
hf : ∀ (j_1 : ι), j_1 ∈ s → j_1 ≠ j → f j_1 ∈ t j_1
x : α j
hx : x ∈ t j
⊢ update f j x j ∈ t j

tactic: rw [update_noteq h]
state_before: case h.refine'_2.inr
ι : Type u_1
α : ι → Type u_2
β : ι → Type ?u.163005
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
inst✝ : DecidableEq ι
f : (i : ι) → α i
hi : i ∈ s
hf : ∀ (j : ι), j ∈ s → j ≠ i → f j ∈ t j
x : α i
hx : x ∈ t i
j : ι
hj : j ∈ s
h : j ≠ i
⊢ update f i x j ∈ t j

tactic: exact hf j hj h
state_before: case h.refine'_2.inr
ι : Type u_1
α : ι → Type u_2
β : ι → Type ?u.163005
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
inst✝ : DecidableEq ι
f : (i : ι) → α i
hi : i ∈ s
hf : ∀ (j : ι), j ∈ s → j ≠ i → f j ∈ t j
x : α i
hx : x ∈ t i
j : ι
hj : j ∈ s
h : j ≠ i
⊢ f j ∈ t j
Theorem: ModuleCat.epi_iff_surjective
File: Mathlib/Algebra/Category/ModuleCat/EpiMono.lean

tactic: rw [epi_iff_range_eq_top, LinearMap.range_eq_top]
state_before: R : Type u
inst✝² : Ring R
X Y : ModuleCat R
f : X ⟶ Y
M : Type v
inst✝¹ : AddCommGroup M
inst✝ : Module R M
⊢ Epi f ↔ Function.Surjective ↑f
Theorem: Finset.biUnion_insert
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [mem_biUnion, exists_prop, mem_union, mem_insert, or_and_right, exists_or,
  exists_eq_left]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.505331
inst✝¹ : DecidableEq β
s s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
inst✝ : DecidableEq α
a : α
x : β
⊢ x ∈ Finset.biUnion (insert a s) t ↔ x ∈ t a ∪ Finset.biUnion s t
Theorem: Equiv.trans_refl
File: Mathlib/Logic/Equiv/Defs.lean

tactic: cases e
state_before: α : Sort u
β : Sort v
γ : Sort w
e : α ≃ β
⊢ e.trans (Equiv.refl β) = e

tactic: rfl
state_before: case mk
α : Sort u
β : Sort v
γ : Sort w
toFun✝ : α → β
invFun✝ : β → α
left_inv✝ : LeftInverse invFun✝ toFun✝
right_inv✝ : Function.RightInverse invFun✝ toFun✝
⊢ { toFun := toFun✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ }.trans (Equiv.refl β) =
    { toFun := toFun✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ }
Theorem: Subgroup.le_normalizer
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: rw [H.mul_mem_cancel_right (H.inv_mem xH), H.mul_mem_cancel_left xH]
state_before: G : Type u_1
G' : Type ?u.383552
inst✝² : Group G
inst✝¹ : Group G'
A : Type ?u.383561
inst✝ : AddGroup A
H K : Subgroup G
x : G
xH : x ∈ H
n : G
⊢ n ∈ H ↔ x * n * x⁻¹ ∈ H
Theorem: CategoryTheory.Limits.pullbackDiagonalMapIso_inv_fst
File: Mathlib/CategoryTheory/Limits/Shapes/Diagonal.lean

tactic: delta pullbackDiagonalMapIso
state_before: C : Type u_2
inst✝² : Category C
X Y Z : C
inst✝¹ : HasPullbacks C
U V₁ V₂ : C
f : X ⟶ Y
i : U ⟶ Y
i₁ : V₁ ⟶ pullback f i
i₂ : V₂ ⟶ pullback f i
inst✝ : HasPullback i₁ i₂
⊢ (pullbackDiagonalMapIso f i i₁ i₂).inv ≫ fst = fst ≫ i₁ ≫ fst

tactic: simp
state_before: C : Type u_2
inst✝² : Category C
X Y Z : C
inst✝¹ : HasPullbacks C
U V₁ V₂ : C
f : X ⟶ Y
i : U ⟶ Y
i₁ : V₁ ⟶ pullback f i
i₂ : V₂ ⟶ pullback f i
inst✝ : HasPullback i₁ i₂
⊢ (Iso.mk (lift (snd ≫ fst) (snd ≫ snd) (_ : (snd ≫ fst) ≫ i₁ = (snd ≫ snd) ≫ i₂))
          (lift (fst ≫ i₁ ≫ fst)
            (map i₁ i₂ (i₁ ≫ snd) (i₂ ≫ snd) (𝟙 V₁) (𝟙 V₂) snd (_ : i₁ ≫ snd = 𝟙 V₁ ≫ i₁ ≫ snd)
              (_ : i₂ ≫ snd = 𝟙 V₂ ≫ i₂ ≫ snd))
            (_ :
              (fst ≫ i₁ ≫ fst) ≫ diagonal f =
                map i₁ i₂ (i₁ ≫ snd) (i₂ ≫ snd) (𝟙 V₁) (𝟙 V₂) snd (_ : i₁ ≫ snd = 𝟙 V₁ ≫ i₁ ≫ snd)
                    (_ : i₂ ≫ snd = 𝟙 V₂ ≫ i₂ ≫ snd) ≫
                  map (i₁ ≫ snd) (i₂ ≫ snd) f f (i₁ ≫ fst) (i₂ ≫ fst) i (_ : (i₁ ≫ snd) ≫ i = (i₁ ≫ fst) ≫ f)
                    (_ : (i₂ ≫ snd) ≫ i = (i₂ ≫ fst) ≫ f)))).inv ≫
      fst =
    fst ≫ i₁ ≫ fst
Theorem: FirstOrder.Language.Substructure.fg_iff_exists_fin_generating_family
File: Mathlib/ModelTheory/FinitelyGenerated.lean

tactic: rw [fg_def]
state_before: L : Language
M : Type u_3
inst✝ : Structure L M
N : Substructure L M
⊢ FG N ↔ ∃ n s, LowerAdjoint.toFun (closure L) (range s) = N

tactic: constructor
state_before: L : Language
M : Type u_3
inst✝ : Structure L M
N : Substructure L M
⊢ (∃ S, Set.Finite S ∧ LowerAdjoint.toFun (closure L) S = N) ↔ ∃ n s, LowerAdjoint.toFun (closure L) (range s) = N

tactic: rintro ⟨S, Sfin, hS⟩
state_before: case mp
L : Language
M : Type u_3
inst✝ : Structure L M
N : Substructure L M
⊢ (∃ S, Set.Finite S ∧ LowerAdjoint.toFun (closure L) S = N) → ∃ n s, LowerAdjoint.toFun (closure L) (range s) = N

tactic: obtain ⟨n, f, rfl⟩ := Sfin.fin_embedding
state_before: case mp.intro.intro
L : Language
M : Type u_3
inst✝ : Structure L M
N : Substructure L M
S : Set M
Sfin : Set.Finite S
hS : LowerAdjoint.toFun (closure L) S = N
⊢ ∃ n s, LowerAdjoint.toFun (closure L) (range s) = N

tactic: exact ⟨n, f, hS⟩
state_before: case mp.intro.intro.intro.intro
L : Language
M : Type u_3
inst✝ : Structure L M
N : Substructure L M
n : ℕ
f : Fin n ↪ M
Sfin : Set.Finite (range ↑f)
hS : LowerAdjoint.toFun (closure L) (range ↑f) = N
⊢ ∃ n s, LowerAdjoint.toFun (closure L) (range s) = N

tactic: rintro ⟨n, s, hs⟩
state_before: case mpr
L : Language
M : Type u_3
inst✝ : Structure L M
N : Substructure L M
⊢ (∃ n s, LowerAdjoint.toFun (closure L) (range s) = N) → ∃ S, Set.Finite S ∧ LowerAdjoint.toFun (closure L) S = N

tactic: refine' ⟨range s, finite_range s, hs⟩
state_before: case mpr.intro.intro
L : Language
M : Type u_3
inst✝ : Structure L M
N : Substructure L M
n : ℕ
s : Fin n → M
hs : LowerAdjoint.toFun (closure L) (range s) = N
⊢ ∃ S, Set.Finite S ∧ LowerAdjoint.toFun (closure L) S = N
Theorem: AddCommGroup.zsmul_modEq_zsmul
File: Mathlib/Algebra/ModEq.lean

tactic: rw [← smul_sub, smul_comm, smul_right_inj hn]
state_before: α : Type u_1
inst✝¹ : AddCommGroup α
p a a₁ a₂ b b₁ b₂ c : α
n : ℕ
z : ℤ
inst✝ : NoZeroSMulDivisors ℤ α
hn : z ≠ 0
m : ℤ
⊢ z • b - z • a = m • z • p ↔ b - a = m • p
Theorem: Nat.ArithmeticFunction.coe_moebius_mul_coe_zeta
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: rw [← coe_coe, ← intCoe_mul, moebius_mul_coe_zeta, intCoe_one]
state_before: R : Type u_1
inst✝ : Ring R
⊢ ↑μ * ↑ζ = 1
Theorem: maximals_mono
File: Mathlib/Order/Minimal.lean

tactic: have := eq_of_mem_maximals ha hb (h _ _ hab)
state_before: α : Type u_1
r r₁ r₂ : α → α → Prop
s t : Set α
a✝ b✝ : α
inst✝ : IsAntisymm α r₂
h : ∀ (a b : α), r₁ a b → r₂ a b
a : α
ha : a ∈ maximals r₂ s
b : α
hb : b ∈ s
hab : r₁ a b
⊢ r₁ b a

tactic: subst this
state_before: α : Type u_1
r r₁ r₂ : α → α → Prop
s t : Set α
a✝ b✝ : α
inst✝ : IsAntisymm α r₂
h : ∀ (a b : α), r₁ a b → r₂ a b
a : α
ha : a ∈ maximals r₂ s
b : α
hb : b ∈ s
hab : r₁ a b
this : a = b
⊢ r₁ b a

tactic: exact hab
state_before: α : Type u_1
r r₁ r₂ : α → α → Prop
s t : Set α
a✝ b : α
inst✝ : IsAntisymm α r₂
h : ∀ (a b : α), r₁ a b → r₂ a b
a : α
ha : a ∈ maximals r₂ s
hb : a ∈ s
hab : r₁ a a
⊢ r₁ a a
Theorem: IsAntichain.max_maximals
File: Mathlib/Order/Minimal.lean

tactic: refine' h.antisymm fun a ha => _
state_before: α : Type u_1
r r₁ r₂ : α → α → Prop
s t : Set α
a b : α
ht : IsAntichain r t
h : maximals r s ⊆ t
hs : ∀ ⦃a : α⦄, a ∈ t → ∃ b, b ∈ maximals r s ∧ r b a
⊢ maximals r s = t

tactic: obtain ⟨b, hb, hr⟩ := hs ha
state_before: α : Type u_1
r r₁ r₂ : α → α → Prop
s t : Set α
a✝ b : α
ht : IsAntichain r t
h : maximals r s ⊆ t
hs : ∀ ⦃a : α⦄, a ∈ t → ∃ b, b ∈ maximals r s ∧ r b a
a : α
ha : a ∈ t
⊢ a ∈ maximals r s

tactic: rwa [of_not_not fun hab => ht (h hb) ha (Ne.symm hab) hr]
state_before: case intro.intro
α : Type u_1
r r₁ r₂ : α → α → Prop
s t : Set α
a✝ b✝ : α
ht : IsAntichain r t
h : maximals r s ⊆ t
hs : ∀ ⦃a : α⦄, a ∈ t → ∃ b, b ∈ maximals r s ∧ r b a
a : α
ha : a ∈ t
b : α
hb : b ∈ maximals r s
hr : r b a
⊢ a ∈ maximals r s
Theorem: hnot_top
File: Mathlib/Order/Heyting/Basic.lean

tactic: rw [← top_sdiff', sdiff_self]
state_before: ι : Type ?u.176665
α : Type u_1
β : Type ?u.176671
inst✝ : CoheytingAlgebra α
a b c : α
⊢ ￢⊤ = ⊥
Theorem: PrimeSpectrum.vanishingIdeal_strict_anti_mono_iff
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

tactic: rw [Set.ssubset_def, vanishingIdeal_anti_mono_iff hs, vanishingIdeal_anti_mono_iff ht,
  lt_iff_le_not_le]
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
s t : Set (PrimeSpectrum R)
hs : IsClosed s
ht : IsClosed t
⊢ s ⊂ t ↔ vanishingIdeal t < vanishingIdeal s
Theorem: Set.Finite.image
File: Mathlib/Data/Set/Finite.lean

tactic: cases hs
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
f : α → β
hs : Set.Finite s
⊢ Set.Finite (f '' s)

tactic: apply toFinite
state_before: case intro
α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
f : α → β
a✝ : Fintype ↑s
⊢ Set.Finite (f '' s)
Theorem: Matrix.blockTriangular_blockDiagonal
File: Mathlib/LinearAlgebra/Matrix/Block.lean

tactic: rintro ⟨i, i'⟩ ⟨j, j'⟩ h
state_before: α : Type u_1
β : Type ?u.32691
m : Type u_2
n : Type ?u.32697
o : Type ?u.32700
m' : α → Type ?u.32705
n' : α → Type ?u.32710
R : Type v
inst✝² : CommRing R
M N : Matrix m m R
b : m → α
inst✝¹ : Preorder α
inst✝ : DecidableEq α
d : α → Matrix m m R
⊢ BlockTriangular (blockDiagonal d) Prod.snd

tactic: rw [blockDiagonal'_eq_blockDiagonal, blockTriangular_blockDiagonal']
state_before: case mk.mk
α : Type u_1
β : Type ?u.32691
m : Type u_2
n : Type ?u.32697
o : Type ?u.32700
m' : α → Type ?u.32705
n' : α → Type ?u.32710
R : Type v
inst✝² : CommRing R
M N : Matrix m m R
b : m → α
inst✝¹ : Preorder α
inst✝ : DecidableEq α
d : α → Matrix m m R
i : m
i' : α
j : m
j' : α
h : (j, j').snd < (i, i').snd
⊢ blockDiagonal d (i, i') (j, j') = 0

tactic: exact h
state_before: case mk.mk.a
α : Type u_1
β : Type ?u.32691
m : Type u_2
n : Type ?u.32697
o : Type ?u.32700
m' : α → Type ?u.32705
n' : α → Type ?u.32710
R : Type v
inst✝² : CommRing R
M N : Matrix m m R
b : m → α
inst✝¹ : Preorder α
inst✝ : DecidableEq α
d : α → Matrix m m R
i : m
i' : α
j : m
j' : α
h : (j, j').snd < (i, i').snd
⊢ { fst := j', snd := j }.fst < { fst := i', snd := i }.fst
Theorem: MeasureTheory.AEStronglyMeasurable.aestronglyMeasurable_uIoc_iff
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

tactic: rw [uIoc_eq_union, aestronglyMeasurable_union_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.402778
ι : Type ?u.402781
inst✝⁴ : Countable ι
m : MeasurableSpace α
μ : Measure α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
f✝ g : α → β
inst✝¹ : LinearOrder α
inst✝ : PseudoMetrizableSpace β
f : α → β
a b : α
⊢ AEStronglyMeasurable f (Measure.restrict μ (Ι a b)) ↔
    AEStronglyMeasurable f (Measure.restrict μ (Ioc a b)) ∧ AEStronglyMeasurable f (Measure.restrict μ (Ioc b a))
Theorem: MeasureTheory.Measure.join_map_join
File: Mathlib/MeasureTheory/Measure/GiryMonad.lean

tactic: show bind μ join = join (join μ)
state_before: α : Type u_1
β : Type ?u.42082
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
μ : Measure (Measure (Measure α))
⊢ join (map join μ) = join (join μ)

tactic: rw [join_eq_bind, join_eq_bind, bind_bind measurable_id measurable_id]
state_before: α : Type u_1
β : Type ?u.42082
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
μ : Measure (Measure (Measure α))
⊢ bind μ join = join (join μ)

tactic: apply congr_arg (bind μ)
state_before: α : Type u_1
β : Type ?u.42082
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
μ : Measure (Measure (Measure α))
⊢ bind μ join = bind μ fun a => bind (id a) id

tactic: funext ν
state_before: α : Type u_1
β : Type ?u.42082
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
μ : Measure (Measure (Measure α))
⊢ join = fun a => bind (id a) id

tactic: exact join_eq_bind ν
state_before: case h
α : Type u_1
β : Type ?u.42082
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
μ : Measure (Measure (Measure α))
ν : Measure (Measure α)
⊢ join ν = bind (id ν) id
Theorem: ENNReal.lt_inv_iff_lt_inv
File: Mathlib/Data/Real/ENNReal.lean

tactic: simpa only [inv_inv] using @ENNReal.inv_lt_inv a⁻¹ b
state_before: α : Type ?u.268007
β : Type ?u.268010
a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ a < b⁻¹ ↔ b < a⁻¹
Theorem: Filter.not_le
File: Mathlib/Order/Filter/Basic.lean

tactic: simp_rw [le_def, not_forall, exists_prop]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.50009
ι : Sort x
f g : Filter α
s t : Set α
⊢ ¬f ≤ g ↔ ∃ s, s ∈ g ∧ ¬s ∈ f
Theorem: Int.floor_int_add
File: Mathlib/Algebra/Order/Floor.lean

tactic: simpa only [add_comm] using floor_add_int a z
state_before: F : Type ?u.133790
α : Type u_1
β : Type ?u.133796
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z✝ : ℤ
a✝ : α
z : ℤ
a : α
⊢ ⌊↑z + a⌋ = z + ⌊a⌋
Theorem: Int.addRight_one_isCycle
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: simp
state_before: ι : Type ?u.3068304
α : Type ?u.3068307
β : Type ?u.3068310
inst✝ : DecidableEq α
n : ℤ
x✝ : ↑(Equiv.addRight 1) n ≠ n
⊢ ↑(Equiv.addRight 1 ^ n) 0 = n
Theorem: Polynomial.aeval_modByMonic_eq_self_of_root
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: rw [modByMonic_eq_sub_mul_div p hq, _root_.map_sub, _root_.map_mul, hx, MulZeroClass.zero_mul,
  sub_zero]
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝² : CommRing R
p✝ q✝ : R[X]
inst✝¹ : Ring S
inst✝ : Algebra R S
p q : R[X]
hq : Monic q
x : S
hx : ↑(aeval x) q = 0
⊢ ↑(aeval x) (p %ₘ q) = ↑(aeval x) p
Theorem: Subgroup.MemRightTransversals.toEquiv_apply
File: Mathlib/GroupTheory/Complement.lean

tactic: refine' (Subtype.ext_iff.mp _).trans (Subtype.coe_mk (f q) ⟨q, rfl⟩)
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
f : Quotient (QuotientGroup.rightRel H) → G
hf : ∀ (q : Quotient (QuotientGroup.rightRel H)), Quotient.mk'' (f q) = q
q : Quotient (QuotientGroup.rightRel H)
⊢ ↑(↑(toEquiv (_ : (Set.range fun q => f q) ∈ rightTransversals ↑H)) q) = f q

tactic: exact (toEquiv (range_mem_rightTransversals hf)).apply_eq_iff_eq_symm_apply.mpr (hf q).symm
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
f : Quotient (QuotientGroup.rightRel H) → G
hf : ∀ (q : Quotient (QuotientGroup.rightRel H)), Quotient.mk'' (f q) = q
q : Quotient (QuotientGroup.rightRel H)
⊢ ↑(toEquiv (_ : (Set.range fun q => f q) ∈ rightTransversals ↑H)) q =
    { val := f q, property := (_ : ∃ y, (fun q => f q) y = f q) }
Theorem: MonoidAlgebra.single_pow
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

tactic: simp only [pow_zero]
state_before: k : Type u₁
G : Type u₂
R : Type ?u.366813
inst✝¹ : Semiring k
inst✝ : Monoid G
a : G
b : k
⊢ single a b ^ 0 = single (a ^ 0) (b ^ 0)

tactic: rfl
state_before: k : Type u₁
G : Type u₂
R : Type ?u.366813
inst✝¹ : Semiring k
inst✝ : Monoid G
a : G
b : k
⊢ 1 = single 1 1

tactic: simp only [pow_succ, single_pow n, single_mul_single]
state_before: k : Type u₁
G : Type u₂
R : Type ?u.366813
inst✝¹ : Semiring k
inst✝ : Monoid G
a : G
b : k
n : ℕ
⊢ single a b ^ (n + 1) = single (a ^ (n + 1)) (b ^ (n + 1))