tasksource/leandojo huggingface dataset:
Theorem: ContinuousLinearEquiv.symm_comp_self
File: Mathlib/Topology/Algebra/Module/Basic.lean

tactic: ext x
state_before: R₁ : Type u_1
R₂ : Type u_2
R₃ : Type ?u.1586825
inst✝²⁴ : Semiring R₁
inst✝²³ : Semiring R₂
inst✝²² : Semiring R₃
σ₁₂ : R₁ →+* R₂
σ₂₁ : R₂ →+* R₁
inst✝²¹ : RingHomInvPair σ₁₂ σ₂₁
inst✝²⁰ : RingHomInvPair σ₂₁ σ₁₂
σ₂₃ : R₂ →+* R₃
σ₃₂ : R₃ →+* R₂
inst✝¹⁹ : RingHomInvPair σ₂₃ σ₃₂
inst✝¹⁸ : RingHomInvPair σ₃₂ σ₂₃
σ₁₃ : R₁ →+* R₃
σ₃₁ : R₃ →+* R₁
inst✝¹⁷ : RingHomInvPair σ₁₃ σ₃₁
inst✝¹⁶ : RingHomInvPair σ₃₁ σ₁₃
inst✝¹⁵ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝¹⁴ : RingHomCompTriple σ₃₂ σ₂₁ σ₃₁
M₁ : Type u_3
inst✝¹³ : TopologicalSpace M₁
inst✝¹² : AddCommMonoid M₁
M'₁ : Type ?u.1587679
inst✝¹¹ : TopologicalSpace M'₁
inst✝¹⁰ : AddCommMonoid M'₁
M₂ : Type u_4
inst✝⁹ : TopologicalSpace M₂
inst✝⁸ : AddCommMonoid M₂
M₃ : Type ?u.1587697
inst✝⁷ : TopologicalSpace M₃
inst✝⁶ : AddCommMonoid M₃
M₄ : Type ?u.1587706
inst✝⁵ : TopologicalSpace M₄
inst✝⁴ : AddCommMonoid M₄
inst✝³ : Module R₁ M₁
inst✝² : Module R₁ M'₁
inst✝¹ : Module R₂ M₂
inst✝ : Module R₃ M₃
e : M₁ ≃SL[σ₁₂] M₂
⊢ ↑(ContinuousLinearEquiv.symm e) ∘ ↑e = id

tactic: exact symm_apply_apply e x
state_before: case h
R₁ : Type u_1
R₂ : Type u_2
R₃ : Type ?u.1586825
inst✝²⁴ : Semiring R₁
inst✝²³ : Semiring R₂
inst✝²² : Semiring R₃
σ₁₂ : R₁ →+* R₂
σ₂₁ : R₂ →+* R₁
inst✝²¹ : RingHomInvPair σ₁₂ σ₂₁
inst✝²⁰ : RingHomInvPair σ₂₁ σ₁₂
σ₂₃ : R₂ →+* R₃
σ₃₂ : R₃ →+* R₂
inst✝¹⁹ : RingHomInvPair σ₂₃ σ₃₂
inst✝¹⁸ : RingHomInvPair σ₃₂ σ₂₃
σ₁₃ : R₁ →+* R₃
σ₃₁ : R₃ →+* R₁
inst✝¹⁷ : RingHomInvPair σ₁₃ σ₃₁
inst✝¹⁶ : RingHomInvPair σ₃₁ σ₁₃
inst✝¹⁵ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝¹⁴ : RingHomCompTriple σ₃₂ σ₂₁ σ₃₁
M₁ : Type u_3
inst✝¹³ : TopologicalSpace M₁
inst✝¹² : AddCommMonoid M₁
M'₁ : Type ?u.1587679
inst✝¹¹ : TopologicalSpace M'₁
inst✝¹⁰ : AddCommMonoid M'₁
M₂ : Type u_4
inst✝⁹ : TopologicalSpace M₂
inst✝⁸ : AddCommMonoid M₂
M₃ : Type ?u.1587697
inst✝⁷ : TopologicalSpace M₃
inst✝⁶ : AddCommMonoid M₃
M₄ : Type ?u.1587706
inst✝⁵ : TopologicalSpace M₄
inst✝⁴ : AddCommMonoid M₄
inst✝³ : Module R₁ M₁
inst✝² : Module R₁ M'₁
inst✝¹ : Module R₂ M₂
inst✝ : Module R₃ M₃
e : M₁ ≃SL[σ₁₂] M₂
x : M₁
⊢ (↑(ContinuousLinearEquiv.symm e) ∘ ↑e) x = id x
Theorem: isNoetherian_iff_wellFounded
File: Mathlib/RingTheory/Noetherian.lean

tactic: have := (CompleteLattice.wellFounded_characterisations <| Submodule R M).out 0 3
state_before: R : Type u_1
M : Type u_2
P : Type ?u.112850
N : Type w
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
⊢ IsNoetherian R M ↔ WellFounded fun x x_1 => x > x_1

tactic: rw [this]
state_before: R : Type u_1
M : Type u_2
P : Type ?u.112850
N : Type w
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
this : (WellFounded fun x x_1 => x > x_1) ↔ ∀ (k : Submodule R M), CompleteLattice.IsCompactElement k
⊢ IsNoetherian R M ↔ WellFounded fun x x_1 => x > x_1

tactic: exact
  ⟨fun ⟨h⟩ => fun k => (fg_iff_compact k).mp (h k), fun h =>
    ⟨fun k => (fg_iff_compact k).mpr (h k)⟩⟩
state_before: R : Type u_1
M : Type u_2
P : Type ?u.112850
N : Type w
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
this : (WellFounded fun x x_1 => x > x_1) ↔ ∀ (k : Submodule R M), CompleteLattice.IsCompactElement k
⊢ IsNoetherian R M ↔ ∀ (k : Submodule R M), CompleteLattice.IsCompactElement k
Theorem: Nat.Primrec.swap'
File: Mathlib/Computability/Primrec.lean

tactic: simp
state_before: f : ℕ → ℕ → ℕ
hf : Nat.Primrec (unpaired f)
n : ℕ
⊢ unpaired f (unpaired (swap Nat.pair) n) = unpaired (swap f) n
Theorem: Subgroup.inf_subgroupOf_left
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: rw [inf_comm, inf_subgroupOf_right]
state_before: G : Type u_1
G' : Type ?u.292171
inst✝⁴ : Group G
inst✝³ : Group G'
A : Type ?u.292180
inst✝² : AddGroup A
H✝ K✝ : Subgroup G
k : Set G
N : Type ?u.292201
inst✝¹ : Group N
P : Type ?u.292207
inst✝ : Group P
H K : Subgroup G
⊢ subgroupOf (K ⊓ H) K = subgroupOf H K
Theorem: Real.hasDerivWithinAt_arcsin_Iic
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/InverseDeriv.lean

tactic: rcases em (x = -1) with (rfl | h')
state_before: x : ℝ
h : x ≠ 1
⊢ HasDerivWithinAt arcsin (1 / sqrt (1 - x ^ 2)) (Iic x) x

tactic: convert (hasDerivWithinAt_const (-1 : ℝ) _ (-(π / 2))).congr _ _ <;>
  simp (config := { contextual := true }) [arcsin_of_le_neg_one]
state_before: case inl
h : -1 ≠ 1
⊢ HasDerivWithinAt arcsin (1 / sqrt (1 - (-1) ^ 2)) (Iic (-1)) (-1)

tactic: exact (hasDerivAt_arcsin h' h).hasDerivWithinAt
state_before: case inr
x : ℝ
h : x ≠ 1
h' : ¬x = -1
⊢ HasDerivWithinAt arcsin (1 / sqrt (1 - x ^ 2)) (Iic x) x
Theorem: UpperSet.codisjoint_prod
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp_rw [codisjoint_iff, prod_sup_prod, prod_eq_top]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.177622
ι : Sort ?u.177625
κ : ι → Sort ?u.177630
inst✝¹ : Preorder α
inst✝ : Preorder β
s s₁ s₂ : UpperSet α
t t₁ t₂ : UpperSet β
x : α × β
⊢ Codisjoint (s₁ ×ˢ t₁) (s₂ ×ˢ t₂) ↔ Codisjoint s₁ s₂ ∨ Codisjoint t₁ t₂
Theorem: Function.Embedding.invFun_restrict
File: Mathlib/Data/Fintype/Basic.lean

tactic: ext ⟨b, h⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.69537
inst✝² : Fintype α
inst✝¹ : DecidableEq β
f : α ↪ β
b : ↑(Set.range ↑f)
inst✝ : Nonempty α
⊢ Set.restrict (Set.range ↑f) (invFun ↑f) = invOfMemRange f

tactic: apply f.injective
state_before: case h.mk
α : Type u_1
β : Type u_2
γ : Type ?u.69537
inst✝² : Fintype α
inst✝¹ : DecidableEq β
f : α ↪ β
b✝ : ↑(Set.range ↑f)
inst✝ : Nonempty α
b : β
h : b ∈ Set.range ↑f
⊢ Set.restrict (Set.range ↑f) (invFun ↑f) { val := b, property := h } = invOfMemRange f { val := b, property := h }

tactic: simp [f.left_inv_of_invOfMemRange, @invFun_eq _ _ _ f b (Set.mem_range.mp h)]
state_before: case h.mk.a
α : Type u_1
β : Type u_2
γ : Type ?u.69537
inst✝² : Fintype α
inst✝¹ : DecidableEq β
f : α ↪ β
b✝ : ↑(Set.range ↑f)
inst✝ : Nonempty α
b : β
h : b ∈ Set.range ↑f
⊢ ↑f (Set.restrict (Set.range ↑f) (invFun ↑f) { val := b, property := h }) =
    ↑f (invOfMemRange f { val := b, property := h })
Theorem: List.TProd.ext
File: Mathlib/Data/Prod/TProd.lean

tactic: apply Prod.ext
state_before: ι : Type u
α : ι → Type v
i✝ j : ι
l : List ι
f : (i : ι) → α i
inst✝ : DecidableEq ι
i : ι
is : List ι
hl : Nodup (i :: is)
v w : TProd α (i :: is)
hvw : ∀ (i_1 : ι) (hi : i_1 ∈ i :: is), TProd.elim v hi = TProd.elim w hi
⊢ v = w

tactic: rw [← elim_self v, hvw, elim_self]
state_before: case h₁
ι : Type u
α : ι → Type v
i✝ j : ι
l : List ι
f : (i : ι) → α i
inst✝ : DecidableEq ι
i : ι
is : List ι
hl : Nodup (i :: is)
v w : TProd α (i :: is)
hvw : ∀ (i_1 : ι) (hi : i_1 ∈ i :: is), TProd.elim v hi = TProd.elim w hi
⊢ v.fst = w.fst

case h₂
ι : Type u
α : ι → Type v
i✝ j : ι
l : List ι
f : (i : ι) → α i
inst✝ : DecidableEq ι
i : ι
is : List ι
hl : Nodup (i :: is)
v w : TProd α (i :: is)
hvw : ∀ (i_1 : ι) (hi : i_1 ∈ i :: is), TProd.elim v hi = TProd.elim w hi
⊢ v.snd = w.snd

tactic: refine' ext (nodup_cons.mp hl).2 fun j hj => _
state_before: case h₂
ι : Type u
α : ι → Type v
i✝ j : ι
l : List ι
f : (i : ι) → α i
inst✝ : DecidableEq ι
i : ι
is : List ι
hl : Nodup (i :: is)
v w : TProd α (i :: is)
hvw : ∀ (i_1 : ι) (hi : i_1 ∈ i :: is), TProd.elim v hi = TProd.elim w hi
⊢ v.snd = w.snd

tactic: rw [← elim_of_mem hl, hvw, elim_of_mem hl]
state_before: case h₂
ι : Type u
α : ι → Type v
i✝ j✝ : ι
l : List ι
f : (i : ι) → α i
inst✝ : DecidableEq ι
i : ι
is : List ι
hl : Nodup (i :: is)
v w : TProd α (i :: is)
hvw : ∀ (i_1 : ι) (hi : i_1 ∈ i :: is), TProd.elim v hi = TProd.elim w hi
j : ι
hj : j ∈ is
⊢ TProd.elim v.snd hj = TProd.elim w.snd hj
Theorem: mul_self_eq_one_iff
File: Mathlib/Algebra/Ring/Commute.lean

tactic: rw [← (Commute.one_right a).mul_self_eq_mul_self_iff, mul_one]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝¹ : NonAssocRing R
inst✝ : NoZeroDivisors R
a : R
⊢ a * a = 1 ↔ a = 1 ∨ a = -1
Theorem: Nat.le_zero_eq
File: src/lean/Init/SimpLemmas.lean

tactic: simp [h]
state_before: a : Nat
h : a = 0
⊢ a ≤ 0
Theorem: Polynomial.rootSet_maps_to'
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: rw [mem_rootSet'] at hx⊢
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]
inst✝⁶ : CommRing T
p : T[X]
S : Type u_1
S' : Type u_2
inst✝⁵ : CommRing S
inst✝⁴ : IsDomain S
inst✝³ : Algebra T S
inst✝² : CommRing S'
inst✝¹ : IsDomain S'
inst✝ : Algebra T S'
hp : map (algebraMap T S') p = 0 → map (algebraMap T S) p = 0
f : S →ₐ[T] S'
x : S
hx : x ∈ rootSet p S
⊢ ↑f x ∈ rootSet p S'

tactic: rw [aeval_algHom, AlgHom.comp_apply, hx.2, _root_.map_zero]
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]
inst✝⁶ : CommRing T
p : T[X]
S : Type u_1
S' : Type u_2
inst✝⁵ : CommRing S
inst✝⁴ : IsDomain S
inst✝³ : Algebra T S
inst✝² : CommRing S'
inst✝¹ : IsDomain S'
inst✝ : Algebra T S'
hp : map (algebraMap T S') p = 0 → map (algebraMap T S) p = 0
f : S →ₐ[T] S'
x : S
hx : map (algebraMap T S) p ≠ 0 ∧ ↑(aeval x) p = 0
⊢ map (algebraMap T S') p ≠ 0 ∧ ↑(aeval (↑f x)) p = 0

tactic: exact ⟨mt hp hx.1, rfl⟩
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]
inst✝⁶ : CommRing T
p : T[X]
S : Type u_1
S' : Type u_2
inst✝⁵ : CommRing S
inst✝⁴ : IsDomain S
inst✝³ : Algebra T S
inst✝² : CommRing S'
inst✝¹ : IsDomain S'
inst✝ : Algebra T S'
hp : map (algebraMap T S') p = 0 → map (algebraMap T S) p = 0
f : S →ₐ[T] S'
x : S
hx : map (algebraMap T S) p ≠ 0 ∧ ↑(aeval x) p = 0
⊢ map (algebraMap T S') p ≠ 0 ∧ 0 = 0
Theorem: Real.one_lt_rpow_iff
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rcases hx.eq_or_lt with (rfl | hx)
state_before: x y z : ℝ
hx : 0 ≤ x
⊢ 1 < x ^ y ↔ 1 < x ∧ 0 < y ∨ 0 < x ∧ x < 1 ∧ y < 0

tactic: rcases _root_.em (y = 0) with (rfl | hy) <;> simp [*, lt_irrefl, (zero_lt_one' ℝ).not_lt]
state_before: case inl
y z : ℝ
hx : 0 ≤ 0
⊢ 1 < 0 ^ y ↔ 1 < 0 ∧ 0 < y ∨ 0 < 0 ∧ 0 < 1 ∧ y < 0

tactic: simp [one_lt_rpow_iff_of_pos hx, hx]
state_before: case inr
x y z : ℝ
hx✝ : 0 ≤ x
hx : 0 < x
⊢ 1 < x ^ y ↔ 1 < x ∧ 0 < y ∨ 0 < x ∧ x < 1 ∧ y < 0
Theorem: Filter.HasBasis.biInter_biUnion_ball
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: ext x
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
p : ι → Prop
U : ι → Set (α × α)
h : HasBasis (𝓤 α) p U
s : Set α
⊢ (⋂ (i : ι) (_ : p i), ⋃ (x : α) (_ : x ∈ s), ball x (U i)) = closure s

tactic: simp [mem_closure_iff_nhds_basis (nhds_basis_uniformity h), ball]
state_before: case h
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
p : ι → Prop
U : ι → Set (α × α)
h : HasBasis (𝓤 α) p U
s : Set α
x : α
⊢ (x ∈ ⋂ (i : ι) (_ : p i), ⋃ (x : α) (_ : x ∈ s), ball x (U i)) ↔ x ∈ closure s
Theorem: Set.filter_mem_univ_eq_toFinset
File: Mathlib/Data/Fintype/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type ?u.98777
γ : Type ?u.98780
s✝ t : Set α
inst✝² : Fintype α
s : Set α
inst✝¹ : Fintype ↑s
inst✝ : DecidablePred fun x => x ∈ s
⊢ filter (fun x => x ∈ s) Finset.univ = toFinset s

tactic: simp only [Finset.mem_univ, decide_eq_true_eq, forall_true_left, mem_filter,
  true_and, mem_toFinset]
state_before: case a
α : Type u_1
β : Type ?u.98777
γ : Type ?u.98780
s✝ t : Set α
inst✝² : Fintype α
s : Set α
inst✝¹ : Fintype ↑s
inst✝ : DecidablePred fun x => x ∈ s
a✝ : α
⊢ a✝ ∈ filter (fun x => x ∈ s) Finset.univ ↔ a✝ ∈ toFinset s
Theorem: Irrational.of_int_mul
File: Mathlib/Data/Real/Irrational.lean

tactic: rwa [cast_coe_int]
state_before: q : ℚ
x y : ℝ
m : ℤ
h : Irrational (↑m * x)
⊢ Irrational (↑↑m * x)
Theorem: surjOn_Ioi_of_monotone_surjective
File: Mathlib/Data/Set/Intervals/SurjOn.lean

tactic: rw [← compl_Iic, ← compl_compl (Ioi (f a))]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : PartialOrder β
f : α → β
h_mono : Monotone f
h_surj : Surjective f
a : α
⊢ SurjOn f (Ioi a) (Ioi (f a))

tactic: refine' MapsTo.surjOn_compl _ h_surj
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : PartialOrder β
f : α → β
h_mono : Monotone f
h_surj : Surjective f
a : α
⊢ SurjOn f (Iic aᶜ) (Ioi (f a)ᶜᶜ)

tactic: exact fun x hx => (h_mono hx).not_lt
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : PartialOrder β
f : α → β
h_mono : Monotone f
h_surj : Surjective f
a : α
⊢ MapsTo f (Iic a) (Ioi (f a)ᶜ)
Theorem: CategoryTheory.Limits.diagonalObjPullbackFstIso_inv_snd_snd
File: Mathlib/CategoryTheory/Limits/Shapes/Diagonal.lean

tactic: delta diagonalObjPullbackFstIso
state_before: C : Type u_2
inst✝⁵ : Category C
X✝ Y✝ Z✝ : C
inst✝⁴ : HasPullbacks C
S T : C
f✝ : X✝ ⟶ T
g✝ : Y✝ ⟶ T
i : T ⟶ S
inst✝³ : HasPullback i i
inst✝² : HasPullback f✝ g✝
inst✝¹ : HasPullback (f✝ ≫ i) (g✝ ≫ i)
inst✝ :
  HasPullback (diagonal i)
    (map (f✝ ≫ i) (g✝ ≫ i) i i f✝ g✝ (𝟙 S) (_ : (f✝ ≫ i) ≫ 𝟙 S = f✝ ≫ i) (_ : (g✝ ≫ i) ≫ 𝟙 S = g✝ ≫ i))
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (diagonalObjPullbackFstIso f g).inv ≫ snd ≫ snd = fst ≫ snd

tactic: simp
state_before: C : Type u_2
inst✝⁵ : Category C
X✝ Y✝ Z✝ : C
inst✝⁴ : HasPullbacks C
S T : C
f✝ : X✝ ⟶ T
g✝ : Y✝ ⟶ T
i : T ⟶ S
inst✝³ : HasPullback i i
inst✝² : HasPullback f✝ g✝
inst✝¹ : HasPullback (f✝ ≫ i) (g✝ ≫ i)
inst✝ :
  HasPullback (diagonal i)
    (map (f✝ ≫ i) (g✝ ≫ i) i i f✝ g✝ (𝟙 S) (_ : (f✝ ≫ i) ≫ 𝟙 S = f✝ ≫ i) (_ : (g✝ ≫ i) ≫ 𝟙 S = g✝ ≫ i))
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (pullbackRightPullbackFstIso f g fst ≪≫
          congrHom (_ : fst ≫ f = snd ≫ g) (_ : g = g) ≪≫
            pullbackAssoc f g g g ≪≫ pullbackSymmetry f (fst ≫ g) ≪≫ congrHom (_ : fst ≫ g = snd ≫ g) (_ : f = f)).inv ≫
      snd ≫ snd =
    fst ≫ snd
Theorem: AddCommGroup.ModEq.add_iff_right
File: Mathlib/Algebra/ModEq.lean

tactic: simp [add_sub_add_comm, hm, add_smul, ModEq]
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a a₁ a₂ b b₁ b₂ c : α
n : ℕ
z : ℤ
x✝ : a₂ ≡ b₂ [PMOD p]
m : ℤ
hm : b₂ - a₂ = m • p
⊢ (∃ b, b₁ + b₂ - (a₁ + a₂) = ↑(Equiv.addRight m).symm.symm b • p) ↔ a₁ ≡ b₁ [PMOD p]
Theorem: Multiset.toDfinsupp_singleton
File: Mathlib/Data/Dfinsupp/Multiset.lean

tactic: rw [← replicate_one, toDfinsupp_replicate]
state_before: α : Type u_1
β : α → Type ?u.43713
inst✝ : DecidableEq α
a : α
⊢ ↑toDfinsupp {a} = Dfinsupp.single a 1
Theorem: map_eq_zero_iff_eq_one
File: Mathlib/Algebra/Order/Hom/Basic.lean

tactic: rintro rfl
state_before: ι : Type ?u.52007
F : Type u_2
α : Type u_3
β : Type u_1
γ : Type ?u.52019
δ : Type ?u.52022
inst✝² : Group α
inst✝¹ : OrderedAddCommMonoid β
inst✝ : GroupNormClass F α β
f : F
x : α
⊢ x = 1 → ↑f x = 0

tactic: exact map_one_eq_zero _
state_before: ι : Type ?u.52007
F : Type u_2
α : Type u_3
β : Type u_1
γ : Type ?u.52019
δ : Type ?u.52022
inst✝² : Group α
inst✝¹ : OrderedAddCommMonoid β
inst✝ : GroupNormClass F α β
f : F
⊢ ↑f 1 = 0
Theorem: Finset.coe_infsep_of_offDiag_empty
File: Mathlib/Topology/MetricSpace/Infsep.lean

tactic: rw [← Finset.not_nonempty_iff_eq_empty] at hs
state_before: α : Type u_1
β : Type ?u.77060
inst✝¹ : PseudoMetricSpace α
x y z : α
s✝ t : Set α
inst✝ : DecidableEq α
s : Finset α
hs : Finset.offDiag s = ∅
⊢ infsep ↑s = 0

tactic: rw [Finset.coe_infsep, dif_neg hs]
state_before: α : Type u_1
β : Type ?u.77060
inst✝¹ : PseudoMetricSpace α
x y z : α
s✝ t : Set α
inst✝ : DecidableEq α
s : Finset α
hs : ¬Finset.Nonempty (Finset.offDiag s)
⊢ infsep ↑s = 0
Theorem: charmatrix_apply_eq
File: Mathlib/LinearAlgebra/Matrix/Charpoly/Basic.lean

tactic: simp only [charmatrix, RingHom.mapMatrix_apply, sub_apply, scalar_apply_eq, map_apply]
state_before: R : Type u
inst✝² : CommRing R
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
M : Matrix n n R
i : n
⊢ charmatrix M i i = X - ↑C (M i i)
Theorem: BoxIntegral.Prepartition.filter_of_true
File: Mathlib/Analysis/BoxIntegral/Partition/Basic.lean

tactic: ext J
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
p : Box ι → Prop
hp : ∀ (J : Box ι), J ∈ π → p J
⊢ filter π p = π

tactic: simpa using hp J
state_before: case h
ι : Type u_1
I J✝ J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
p : Box ι → Prop
hp : ∀ (J : Box ι), J ∈ π → p J
J : Box ι
⊢ J ∈ filter π p ↔ J ∈ π
Theorem: PadicInt.pow_p_dvd_int_iff
File: Mathlib/NumberTheory/Padics/PadicIntegers.lean

tactic: rw [← Nat.cast_pow, ← norm_int_le_pow_iff_dvd, norm_le_pow_iff_mem_span_pow,
  Ideal.mem_span_singleton, Nat.cast_pow]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
a : ℤ
⊢ ↑p ^ n ∣ ↑a ↔ ↑(p ^ n) ∣ a
Theorem: forall_apply_eq_imp_iff
File: Mathlib/Logic/Basic.lean

tactic: simp
state_before: ι : Sort ?u.18610
α : Sort ?u.18615
κ : ι → Sort ?u.18612
p✝ q : α → Prop
β : Sort u_1
f : α → β
p : β → Prop
⊢ (∀ (a : α) (b : β), f a = b → p b) ↔ ∀ (a : α), p (f a)
Theorem: Polynomial.div_wf_lemma
File: Mathlib/Data/Polynomial/Div.lean

tactic: rw [← Nat.cast_withBot, ← Nat.cast_withBot, ← degree_eq_natDegree h.2,
← degree_eq_natDegree hq0]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p q : R[X]
h : degree q ≤ degree p ∧ p ≠ 0
hq : Monic q
hp : leadingCoeff p ≠ 0
hq0 : q ≠ 0
⊢ ↑(natDegree q) ≤ ↑(natDegree p)

tactic: exact h.1
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p q : R[X]
h : degree q ≤ degree p ∧ p ≠ 0
hq : Monic q
hp : leadingCoeff p ≠ 0
hq0 : q ≠ 0
⊢ degree q ≤ degree p

tactic: rw [hq.degree_mul, degree_C_mul_X_pow _ hp, degree_eq_natDegree h.2,
  degree_eq_natDegree hq0, ← Nat.cast_add, tsub_add_cancel_of_le hlt]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p q : R[X]
h : degree q ≤ degree p ∧ p ≠ 0
hq : Monic q
hp : leadingCoeff p ≠ 0
hq0 : q ≠ 0
hlt : natDegree q ≤ natDegree p
⊢ degree p = degree (↑C (leadingCoeff p) * X ^ (natDegree p - natDegree q) * q)

tactic: rw [leadingCoeff_mul_monic hq, leadingCoeff_mul_X_pow, leadingCoeff_C]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p q : R[X]
h : degree q ≤ degree p ∧ p ≠ 0
hq : Monic q
hp : leadingCoeff p ≠ 0
hq0 : q ≠ 0
hlt : natDegree q ≤ natDegree p
⊢ leadingCoeff p = leadingCoeff (↑C (leadingCoeff p) * X ^ (natDegree p - natDegree q) * q)
Theorem: Subbimodule.smul_mem
File: Mathlib/Algebra/Module/Bimodule.lean

tactic: suffices a • m = a ⊗ₜ[R] (1 : B) • m by exact this.symm ▸ p.smul_mem _ hm
state_before: R : Type u_4
A : Type u_2
B : Type u_1
M : Type u_3
inst✝¹¹ : CommSemiring R
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : Module R M
inst✝⁸ : Semiring A
inst✝⁷ : Semiring B
inst✝⁶ : Module A M
inst✝⁵ : Module B M
inst✝⁴ : Algebra R A
inst✝³ : Algebra R B
inst✝² : IsScalarTower R A M
inst✝¹ : IsScalarTower R B M
inst✝ : SMulCommClass A B M
p : Submodule (A ⊗[R] B) M
a : A
m : M
hm : m ∈ p
⊢ a • m ∈ p

tactic: simp [TensorProduct.Algebra.smul_def]
state_before: R : Type u_4
A : Type u_2
B : Type u_1
M : Type u_3
inst✝¹¹ : CommSemiring R
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : Module R M
inst✝⁸ : Semiring A
inst✝⁷ : Semiring B
inst✝⁶ : Module A M
inst✝⁵ : Module B M
inst✝⁴ : Algebra R A
inst✝³ : Algebra R B
inst✝² : IsScalarTower R A M
inst✝¹ : IsScalarTower R B M
inst✝ : SMulCommClass A B M
p : Submodule (A ⊗[R] B) M
a : A
m : M
hm : m ∈ p
⊢ a • m = a ⊗ₜ[R] 1 • m

tactic: exact this.symm ▸ p.smul_mem _ hm
state_before: R : Type u_4
A : Type u_2
B : Type u_1
M : Type u_3
inst✝¹¹ : CommSemiring R
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : Module R M
inst✝⁸ : Semiring A
inst✝⁷ : Semiring B
inst✝⁶ : Module A M
inst✝⁵ : Module B M
inst✝⁴ : Algebra R A
inst✝³ : Algebra R B
inst✝² : IsScalarTower R A M
inst✝¹ : IsScalarTower R B M
inst✝ : SMulCommClass A B M
p : Submodule (A ⊗[R] B) M
a : A
m : M
hm : m ∈ p
this : a • m = a ⊗ₜ[R] 1 • m
⊢ a • m ∈ p
Theorem: Ordinal.derivFamily_eq_enumOrd
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

tactic: rw [← eq_enumOrd _ (fp_family_unbounded.{u, v} H)]
state_before: ι : Type u
f : ι → Ordinal → Ordinal
H : ∀ (i : ι), IsNormal (f i)
⊢ derivFamily f = enumOrd (⋂ (i : ι), fixedPoints (f i))

tactic: use (derivFamily_isNormal f).strictMono
state_before: ι : Type u
f : ι → Ordinal → Ordinal
H : ∀ (i : ι), IsNormal (f i)
⊢ StrictMono (derivFamily f) ∧ Set.range (derivFamily f) = ⋂ (i : ι), fixedPoints (f i)

tactic: rw [Set.range_eq_iff]
state_before: ι : Type u
f : ι → Ordinal → Ordinal
H : ∀ (i : ι), IsNormal (f i)
⊢ Set.range (derivFamily f) = ⋂ (i : ι), fixedPoints (f i)

tactic: refine' ⟨_, fun a ha => _⟩
state_before: ι : Type u
f : ι → Ordinal → Ordinal
H : ∀ (i : ι), IsNormal (f i)
⊢ (∀ (a : Ordinal), derivFamily f a ∈ ⋂ (i : ι), fixedPoints (f i)) ∧
    ∀ (b : Ordinal), (b ∈ ⋂ (i : ι), fixedPoints (f i)) → ∃ a, derivFamily f a = b

tactic: rw [Set.mem_iInter] at ha
state_before: case refine'_2
ι : Type u
f : ι → Ordinal → Ordinal
H : ∀ (i : ι), IsNormal (f i)
a : Ordinal
ha : a ∈ ⋂ (i : ι), fixedPoints (f i)
⊢ ∃ a_1, derivFamily f a_1 = a

tactic: rwa [← fp_iff_derivFamily H]
state_before: case refine'_2
ι : Type u
f : ι → Ordinal → Ordinal
H : ∀ (i : ι), IsNormal (f i)
a : Ordinal
ha : ∀ (i : ι), a ∈ fixedPoints (f i)
⊢ ∃ a_1, derivFamily f a_1 = a

tactic: rintro a S ⟨i, hi⟩
state_before: case refine'_1
ι : Type u
f : ι → Ordinal → Ordinal
H : ∀ (i : ι), IsNormal (f i)
⊢ ∀ (a : Ordinal), derivFamily f a ∈ ⋂ (i : ι), fixedPoints (f i)

tactic: rw [← hi]
state_before: case refine'_1.intro
ι : Type u
f : ι → Ordinal → Ordinal
H : ∀ (i : ι), IsNormal (f i)
a : Ordinal
S : Set Ordinal
i : ι
hi : (fun i => fixedPoints (f i)) i = S
⊢ derivFamily f a ∈ S

tactic: exact derivFamily_fp (H i) a
state_before: case refine'_1.intro
ι : Type u
f : ι → Ordinal → Ordinal
H : ∀ (i : ι), IsNormal (f i)
a : Ordinal
S : Set Ordinal
i : ι
hi : (fun i => fixedPoints (f i)) i = S
⊢ derivFamily f a ∈ (fun i => fixedPoints (f i)) i
Theorem: Set.image_mul_left_Ioo
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: convert image_mul_right_Ioo b c h using 1 <;> simp only [mul_comm _ a]
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a : α
h : 0 < a
b c : α
⊢ (fun x x_1 => x * x_1) a '' Ioo b c = Ioo (a * b) (a * c)