tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.isSeparator_iff_epi
File: Mathlib/CategoryTheory/Generator.lean

tactic: rw [isSeparator_def]
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
G : C
inst✝ : ∀ (A : C), HasCoproduct fun x => G
⊢ IsSeparator G ↔ ∀ (A : C), Epi (Sigma.desc fun f => f)

tactic: refine' ⟨fun h A => ⟨fun u v huv => h _ _ fun i => _⟩, fun h X Y f g hh => _⟩
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
G : C
inst✝ : ∀ (A : C), HasCoproduct fun x => G
⊢ (∀ ⦃X Y : C⦄ (f g : X ⟶ Y), (∀ (h : G ⟶ X), h ≫ f = h ≫ g) → f = g) ↔ ∀ (A : C), Epi (Sigma.desc fun f => f)

tactic: simpa using Sigma.ι _ i ≫= huv
state_before: case refine'_1
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
G : C
inst✝ : ∀ (A : C), HasCoproduct fun x => G
h : ∀ ⦃X Y : C⦄ (f g : X ⟶ Y), (∀ (h : G ⟶ X), h ≫ f = h ≫ g) → f = g
A Z✝ : C
u v : A ⟶ Z✝
huv : (Sigma.desc fun f => f) ≫ u = (Sigma.desc fun f => f) ≫ v
i : G ⟶ A
⊢ i ≫ u = i ≫ v

tactic: haveI := h X
state_before: case refine'_2
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
G : C
inst✝ : ∀ (A : C), HasCoproduct fun x => G
h : ∀ (A : C), Epi (Sigma.desc fun f => f)
X Y : C
f g : X ⟶ Y
hh : ∀ (h : G ⟶ X), h ≫ f = h ≫ g
⊢ f = g

tactic: refine' (cancel_epi (Sigma.desc fun f : G ⟶ X => f)).1 (colimit.hom_ext fun j => _)
state_before: case refine'_2
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
G : C
inst✝ : ∀ (A : C), HasCoproduct fun x => G
h : ∀ (A : C), Epi (Sigma.desc fun f => f)
X Y : C
f g : X ⟶ Y
hh : ∀ (h : G ⟶ X), h ≫ f = h ≫ g
this : Epi (Sigma.desc fun f => f)
⊢ f = g

tactic: simpa using hh j.as
state_before: case refine'_2
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
G : C
inst✝ : ∀ (A : C), HasCoproduct fun x => G
h : ∀ (A : C), Epi (Sigma.desc fun f => f)
X Y : C
f g : X ⟶ Y
hh : ∀ (h : G ⟶ X), h ≫ f = h ≫ g
this : Epi (Sigma.desc fun f => f)
j : Discrete (G ⟶ X)
⊢ colimit.ι (Discrete.functor fun f => G) j ≫ (Sigma.desc fun f => f) ≫ f =
    colimit.ι (Discrete.functor fun f => G) j ≫ (Sigma.desc fun f => f) ≫ g
Theorem: CategoryTheory.isDetector_op_iff
File: Mathlib/CategoryTheory/Generator.lean

tactic: rw [IsDetector, IsCodetector, ← isDetecting_op_iff, Set.singleton_op]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
G : C
⊢ IsDetector G.op ↔ IsCodetector G
Theorem: CategoryTheory.CosimplicialObject.δ_comp_δ_self
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

tactic: dsimp [δ]
state_before: C : Type u
inst✝ : Category C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 2)
⊢ δ X i ≫ δ X (↑Fin.castSucc i) = δ X i ≫ δ X (Fin.succ i)

tactic: simp only [← X.map_comp, SimplexCategory.δ_comp_δ_self]
state_before: C : Type u
inst✝ : Category C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 2)
⊢ X.map (SimplexCategory.δ i) ≫ X.map (SimplexCategory.δ (↑Fin.castSucc i)) =
    X.map (SimplexCategory.δ i) ≫ X.map (SimplexCategory.δ (Fin.succ i))
Theorem: LiouvilleWith.int_mul_iff
File: Mathlib/NumberTheory/Liouville/LiouvilleWith.lean

tactic: rw [mul_comm, mul_int_iff hm]
state_before: p q x y : ℝ
r : ℚ
m : ℤ
n : ℕ
hm : m ≠ 0
⊢ LiouvilleWith p (↑m * x) ↔ LiouvilleWith p x
Theorem: Matrix.row_add
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type ?u.1213129
m : Type u_1
n : Type ?u.1213135
o : Type ?u.1213138
m' : o → Type ?u.1213143
n' : o → Type ?u.1213148
R : Type ?u.1213151
S : Type ?u.1213154
α : Type v
β : Type w
γ : Type ?u.1213161
inst✝ : Add α
v w : m → α
⊢ row (v + w) = row v + row w

tactic: rfl
state_before: case a.h
l : Type ?u.1213129
m : Type u_1
n : Type ?u.1213135
o : Type ?u.1213138
m' : o → Type ?u.1213143
n' : o → Type ?u.1213148
R : Type ?u.1213151
S : Type ?u.1213154
α : Type v
β : Type w
γ : Type ?u.1213161
inst✝ : Add α
v w : m → α
i✝ : Unit
x✝ : m
⊢ row (v + w) i✝ x✝ = (row v + row w) i✝ x✝
Theorem: Set.ncard_exchange
File: Mathlib/Data/Set/Ncard.lean

tactic: cases' s.finite_or_infinite with h h
state_before: α : Type u_1
β : Type ?u.20177
s t : Set α
a b x y : α
f : α → β
ha : ¬a ∈ s
hb : b ∈ s
⊢ ncard (insert a (s \ {b})) = ncard s

tactic: rw [((h.diff (Set.toFinite {b})).mono (subset_insert _ _)).ncard, h.ncard]
state_before: case inr
α : Type u_1
β : Type ?u.20177
s t : Set α
a b x y : α
f : α → β
ha : ¬a ∈ s
hb : b ∈ s
h : Set.Infinite s
⊢ ncard (insert a (s \ {b})) = ncard s

tactic: haveI := h.to_subtype
state_before: case inl
α : Type u_1
β : Type ?u.20177
s t : Set α
a b x y : α
f : α → β
ha : ¬a ∈ s
hb : b ∈ s
h : Set.Finite s
⊢ ncard (insert a (s \ {b})) = ncard s

tactic: rw [ncard_insert_of_not_mem, ncard_diff_singleton_add_one hb]
state_before: case inl
α : Type u_1
β : Type ?u.20177
s t : Set α
a b x y : α
f : α → β
ha : ¬a ∈ s
hb : b ∈ s
h : Set.Finite s
this : Finite ↑s
⊢ ncard (insert a (s \ {b})) = ncard s

tactic: simp [mem_diff, not_and, not_not, ha]
state_before: case inl
α : Type u_1
β : Type ?u.20177
s t : Set α
a b x y : α
f : α → β
ha : ¬a ∈ s
hb : b ∈ s
h : Set.Finite s
this : Finite ↑s
⊢ ¬a ∈ s \ {b}
Theorem: FreeProduct.NeWord.inv_prod
File: Mathlib/GroupTheory/FreeProduct.lean

tactic: induction w <;> simp [inv, *]
state_before: ι : Type u_1
M : ι → Type ?u.643406
inst✝² : (i : ι) → Monoid (M i)
N : Type ?u.643417
inst✝¹ : Monoid N
G : ι → Type u_2
inst✝ : (i : ι) → Group (G i)
i j : ι
w : NeWord G i j
⊢ prod (inv w) = (prod w)⁻¹
Theorem: Fin.comp_init
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: ext j
state_before: m n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ (last n)
q✝ : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ (↑castSucc i)
i : Fin n
y : α✝ (↑castSucc i)
z : α✝ (last n)
α : Type u_1
β : Type u_2
g : α → β
q : Fin (Nat.succ n) → α
⊢ g ∘ init q = init (g ∘ q)

tactic: simp [init]
state_before: case h
m n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ (last n)
q✝ : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ (↑castSucc i)
i : Fin n
y : α✝ (↑castSucc i)
z : α✝ (last n)
α : Type u_1
β : Type u_2
g : α → β
q : Fin (Nat.succ n) → α
j : Fin n
⊢ (g ∘ init q) j = init (g ∘ q) j
Theorem: frontier_empty
File: Mathlib/Topology/Basic.lean

tactic: simp [frontier]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
⊢ frontier ∅ = ∅
Theorem: Equiv.Perm.extendDomain_apply_image
File: Mathlib/Logic/Equiv/Basic.lean

tactic: simp [Perm.extendDomain]
state_before: α' : Type u_2
β' : Type u_1
e : Perm α'
p : β' → Prop
inst✝ : DecidablePred p
f : α' ≃ Subtype p
a : α'
⊢ ↑(extendDomain e f) ↑(↑f a) = ↑(↑f (↑e a))
Theorem: dvd_generator_iff
File: Mathlib/LinearAlgebra/FreeModule/PID.lean

tactic: conv_rhs => rw [← span_singleton_generator I]
state_before: ι : Type ?u.23103
R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
M : Type ?u.23295
inst✝² : AddCommGroup M
inst✝¹ : Module R M
b : ι → M
I : Ideal R
inst✝ : IsPrincipal I
x : R
hx : x ∈ I
⊢ x ∣ generator I ↔ I = Ideal.span {x}

tactic: rw [Ideal.submodule_span_eq, Ideal.span_singleton_eq_span_singleton, ← dvd_dvd_iff_associated,
  ← mem_iff_generator_dvd]
state_before: ι : Type ?u.23103
R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
M : Type ?u.23295
inst✝² : AddCommGroup M
inst✝¹ : Module R M
b : ι → M
I : Ideal R
inst✝ : IsPrincipal I
x : R
hx : x ∈ I
⊢ x ∣ generator I ↔ span R {generator I} = Ideal.span {x}

tactic: exact ⟨fun h ↦ ⟨hx, h⟩, fun h ↦ h.2⟩
state_before: ι : Type ?u.23103
R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
M : Type ?u.23295
inst✝² : AddCommGroup M
inst✝¹ : Module R M
b : ι → M
I : Ideal R
inst✝ : IsPrincipal I
x : R
hx : x ∈ I
⊢ x ∣ generator I ↔ x ∈ I ∧ x ∣ generator I
Theorem: PEquiv.toMatrix_symm
File: Mathlib/Data/Matrix/PEquiv.lean

tactic: ext
state_before: k : Type ?u.7888
l : Type ?u.7891
m : Type u_1
n : Type u_2
α : Type v
inst✝³ : DecidableEq m
inst✝² : DecidableEq n
inst✝¹ : Zero α
inst✝ : One α
f : m ≃. n
⊢ toMatrix (PEquiv.symm f) = (toMatrix f)ᵀ

tactic: simp only [transpose, mem_iff_mem f, toMatrix_apply]
state_before: case a.h
k : Type ?u.7888
l : Type ?u.7891
m : Type u_1
n : Type u_2
α : Type v
inst✝³ : DecidableEq m
inst✝² : DecidableEq n
inst✝¹ : Zero α
inst✝ : One α
f : m ≃. n
i✝ : n
x✝ : m
⊢ toMatrix (PEquiv.symm f) i✝ x✝ = (toMatrix f)ᵀ i✝ x✝

tactic: congr
state_before: case a.h
k : Type ?u.7888
l : Type ?u.7891
m : Type u_1
n : Type u_2
α : Type v
inst✝³ : DecidableEq m
inst✝² : DecidableEq n
inst✝¹ : Zero α
inst✝ : One α
f : m ≃. n
i✝ : n
x✝ : m
⊢ (if i✝ ∈ ↑f x✝ then 1 else 0) = ↑of (fun x y => if x ∈ ↑f y then 1 else 0) i✝ x✝
Theorem: Ordnode.all_node3L
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: simp [node3L, all_node', and_assoc]
state_before: α : Type u_1
P : α → Prop
l : Ordnode α
x : α
m : Ordnode α
y : α
r : Ordnode α
⊢ All P (node3L l x m y r) ↔ All P l ∧ P x ∧ All P m ∧ P y ∧ All P r
Theorem: Finset.prod_multiset_map_count
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: refine' Quot.induction_on s fun l => _
state_before: ι : Type ?u.552476
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝² : CommMonoid β
inst✝¹ : DecidableEq α
s : Multiset α
M : Type u_1
inst✝ : CommMonoid M
f : α → M
⊢ Multiset.prod (Multiset.map f s) = ∏ m in Multiset.toFinset s, f m ^ Multiset.count m s

tactic: simp [prod_list_map_count l f]
state_before: ι : Type ?u.552476
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝² : CommMonoid β
inst✝¹ : DecidableEq α
s : Multiset α
M : Type u_1
inst✝ : CommMonoid M
f : α → M
l : List α
⊢ Multiset.prod (Multiset.map f (Quot.mk Setoid.r l)) =
    ∏ m in Multiset.toFinset (Quot.mk Setoid.r l), f m ^ Multiset.count m (Quot.mk Setoid.r l)
Theorem: Set.ncard_diff_add_ncard
File: Mathlib/Data/Set/Ncard.lean

tactic: rw [← union_diff_right, ncard_diff_add_ncard_eq_ncard (subset_union_right s t) (hs.union ht)]
state_before: α : Type u_1
β : Type ?u.127365
s✝ t✝ : Set α
a b x y : α
f : α → β
s t : Set α
hs : autoParam (Set.Finite s) _auto✝
ht : autoParam (Set.Finite t) _auto✝
⊢ ncard (s \ t) + ncard t = ncard (s ∪ t)
Theorem: AffineSubspace.sSameSide_iff_exists_left
File: Mathlib/Analysis/Convex/Side.lean

tactic: rw [SSameSide, and_comm, wSameSide_iff_exists_left h, and_assoc, and_congr_right_iff]
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.246833
P : Type u_3
P' : Type ?u.246839
inst✝⁶ : LinearOrderedField R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y p₁ : P
h : p₁ ∈ s
⊢ SSameSide s x y ↔ ¬x ∈ s ∧ ¬y ∈ s ∧ ∃ p₂, p₂ ∈ s ∧ SameRay R (x -ᵥ p₁) (y -ᵥ p₂)

tactic: intro hx
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.246833
P : Type u_3
P' : Type ?u.246839
inst✝⁶ : LinearOrderedField R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y p₁ : P
h : p₁ ∈ s
⊢ ¬x ∈ s →
    (¬y ∈ s ∧ (x ∈ s ∨ ∃ p₂, p₂ ∈ s ∧ SameRay R (x -ᵥ p₁) (y -ᵥ p₂)) ↔
      ¬y ∈ s ∧ ∃ p₂, p₂ ∈ s ∧ SameRay R (x -ᵥ p₁) (y -ᵥ p₂))

tactic: rw [or_iff_right hx]
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.246833
P : Type u_3
P' : Type ?u.246839
inst✝⁶ : LinearOrderedField R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y p₁ : P
h : p₁ ∈ s
hx : ¬x ∈ s
⊢ ¬y ∈ s ∧ (x ∈ s ∨ ∃ p₂, p₂ ∈ s ∧ SameRay R (x -ᵥ p₁) (y -ᵥ p₂)) ↔
    ¬y ∈ s ∧ ∃ p₂, p₂ ∈ s ∧ SameRay R (x -ᵥ p₁) (y -ᵥ p₂)
Theorem: List.Pairwise.and_mem
File: Mathlib/Data/List/Pairwise.lean

tactic: simp (config := { contextual := true }) only [true_and_iff, iff_self_iff, forall₂_true_iff]
state_before: α : Type u_1
β : Type ?u.4180
R S T : α → α → Prop
a : α
l✝ l : List α
⊢ ∀ {a b : α}, a ∈ l → b ∈ l → (R a b ↔ a ∈ l ∧ b ∈ l ∧ R a b)
Theorem: Zsqrtd.norm_neg
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: rw [norm_eq_mul_conj, star_neg, neg_mul_neg, norm_eq_mul_conj]
state_before: d : ℤ
x : ℤ√d
⊢ ↑(norm (-x)) = ↑(norm x)
Theorem: Equiv.swap_apply_eq_iff
File: Mathlib/Logic/Equiv/Basic.lean

tactic: rw [apply_eq_iff_eq_symm_apply, symm_swap]
state_before: α : Sort u_1
inst✝ : DecidableEq α
x y z w : α
⊢ ↑(swap x y) z = w ↔ z = ↑(swap x y) w
Theorem: NonarchimedeanGroup.nonarchimedean_of_emb
File: Mathlib/Topology/Algebra/Nonarchimedean/Basic.lean

tactic: apply emb.continuous.tendsto
state_before: G : Type u_1
inst✝⁸ : Group G
inst✝⁷ : TopologicalSpace G
inst✝⁶ : NonarchimedeanGroup G
H : Type u_2
inst✝⁵ : Group H
inst✝⁴ : TopologicalSpace H
inst✝³ : TopologicalGroup H
K : Type ?u.2210
inst✝² : Group K
inst✝¹ : TopologicalSpace K
inst✝ : NonarchimedeanGroup K
f : G →* H
emb : OpenEmbedding ↑f
U : Set H
hU : U ∈ nhds 1
⊢ ↑f ⁻¹' U ∈ nhds 1

tactic: rwa [f.map_one]
state_before: case a
G : Type u_1
inst✝⁸ : Group G
inst✝⁷ : TopologicalSpace G
inst✝⁶ : NonarchimedeanGroup G
H : Type u_2
inst✝⁵ : Group H
inst✝⁴ : TopologicalSpace H
inst✝³ : TopologicalGroup H
K : Type ?u.2210
inst✝² : Group K
inst✝¹ : TopologicalSpace K
inst✝ : NonarchimedeanGroup K
f : G →* H
emb : OpenEmbedding ↑f
U : Set H
hU : U ∈ nhds 1
⊢ U ∈ nhds (↑f 1)
Theorem: LinearMap.ker_dualMap_eq_dualAnnihilator_range
File: Mathlib/LinearAlgebra/Dual.lean

tactic: ext φ
state_before: R : Type u
inst✝⁴ : CommSemiring R
M₁ : Type v
M₂ : Type v'
inst✝³ : AddCommMonoid M₁
inst✝² : Module R M₁
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R M₂
f : M₁ →ₗ[R] M₂
⊢ ker (dualMap f) = Submodule.dualAnnihilator (range f)

tactic: constructor <;> intro hφ
state_before: case h
R : Type u
inst✝⁴ : CommSemiring R
M₁ : Type v
M₂ : Type v'
inst✝³ : AddCommMonoid M₁
inst✝² : Module R M₁
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R M₂
f : M₁ →ₗ[R] M₂
φ : Dual R M₂
⊢ φ ∈ ker (dualMap f) ↔ φ ∈ Submodule.dualAnnihilator (range f)

tactic: rw [mem_ker] at hφ
state_before: case h.mp
R : Type u
inst✝⁴ : CommSemiring R
M₁ : Type v
M₂ : Type v'
inst✝³ : AddCommMonoid M₁
inst✝² : Module R M₁
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R M₂
f : M₁ →ₗ[R] M₂
φ : Dual R M₂
hφ : φ ∈ ker (dualMap f)
⊢ φ ∈ Submodule.dualAnnihilator (range f)

tactic: rw [Submodule.mem_dualAnnihilator]
state_before: case h.mp
R : Type u
inst✝⁴ : CommSemiring R
M₁ : Type v
M₂ : Type v'
inst✝³ : AddCommMonoid M₁
inst✝² : Module R M₁
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R M₂
f : M₁ →ₗ[R] M₂
φ : Dual R M₂
hφ : ↑(dualMap f) φ = 0
⊢ φ ∈ Submodule.dualAnnihilator (range f)

tactic: rintro y ⟨x, rfl⟩
state_before: case h.mp
R : Type u
inst✝⁴ : CommSemiring R
M₁ : Type v
M₂ : Type v'
inst✝³ : AddCommMonoid M₁
inst✝² : Module R M₁
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R M₂
f : M₁ →ₗ[R] M₂
φ : Dual R M₂
hφ : ↑(dualMap f) φ = 0
⊢ ∀ (w : M₂), w ∈ range f → ↑φ w = 0

tactic: rw [← dualMap_apply, hφ, zero_apply]
state_before: case h.mp.intro
R : Type u
inst✝⁴ : CommSemiring R
M₁ : Type v
M₂ : Type v'
inst✝³ : AddCommMonoid M₁
inst✝² : Module R M₁
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R M₂
f : M₁ →ₗ[R] M₂
φ : Dual R M₂
hφ : ↑(dualMap f) φ = 0
x : M₁
⊢ ↑φ (↑f x) = 0

tactic: ext x
state_before: case h.mpr
R : Type u
inst✝⁴ : CommSemiring R
M₁ : Type v
M₂ : Type v'
inst✝³ : AddCommMonoid M₁
inst✝² : Module R M₁
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R M₂
f : M₁ →ₗ[R] M₂
φ : Dual R M₂
hφ : φ ∈ Submodule.dualAnnihilator (range f)
⊢ φ ∈ ker (dualMap f)

tactic: rw [dualMap_apply]
state_before: case h.mpr.h
R : Type u
inst✝⁴ : CommSemiring R
M₁ : Type v
M₂ : Type v'
inst✝³ : AddCommMonoid M₁
inst✝² : Module R M₁
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R M₂
f : M₁ →ₗ[R] M₂
φ : Dual R M₂
hφ : φ ∈ Submodule.dualAnnihilator (range f)
x : M₁
⊢ ↑(↑(dualMap f) φ) x = ↑0 x

tactic: rw [Submodule.mem_dualAnnihilator] at hφ
state_before: case h.mpr.h
R : Type u
inst✝⁴ : CommSemiring R
M₁ : Type v
M₂ : Type v'
inst✝³ : AddCommMonoid M₁
inst✝² : Module R M₁
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R M₂
f : M₁ →ₗ[R] M₂
φ : Dual R M₂
hφ : φ ∈ Submodule.dualAnnihilator (range f)
x : M₁
⊢ ↑φ (↑f x) = ↑0 x

tactic: exact hφ (f x) ⟨x, rfl⟩
state_before: case h.mpr.h
R : Type u
inst✝⁴ : CommSemiring R
M₁ : Type v
M₂ : Type v'
inst✝³ : AddCommMonoid M₁
inst✝² : Module R M₁
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R M₂
f : M₁ →ₗ[R] M₂
φ : Dual R M₂
hφ : ∀ (w : M₂), w ∈ range f → ↑φ w = 0
x : M₁
⊢ ↑φ (↑f x) = ↑0 x
Theorem: wittPolynomial_eq_sum_c_mul_x_pow
File: Mathlib/RingTheory/WittVector/WittPolynomial.lean

tactic: apply sum_congr rfl
state_before: p : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : DecidableEq R
n : ℕ
⊢ wittPolynomial p R n = ∑ i in range (n + 1), ↑C (↑p ^ i) * X i ^ p ^ (n - i)

tactic: rintro i -
state_before: p : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : DecidableEq R
n : ℕ
⊢ ∀ (x : ℕ), x ∈ range (n + 1) → ↑(monomial (single x (p ^ (n - x)))) (↑p ^ x) = ↑C (↑p ^ x) * X x ^ p ^ (n - x)

tactic: rw [monomial_eq, Finsupp.prod_single_index]
state_before: p : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : DecidableEq R
n i : ℕ
⊢ ↑(monomial (single i (p ^ (n - i)))) (↑p ^ i) = ↑C (↑p ^ i) * X i ^ p ^ (n - i)

tactic: rw [pow_zero]
state_before: p : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : DecidableEq R
n i : ℕ
⊢ X i ^ 0 = 1
Theorem: isClosed_range_inl
File: Mathlib/Topology/Constructions.lean

tactic: rw [← isOpen_compl_iff, compl_range_inl]
state_before: α : Type u
β : Type v
γ : Type ?u.140260
δ : Type ?u.140263
ε : Type ?u.140266
ζ : Type ?u.140269
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
⊢ IsClosed (range inl)

tactic: exact isOpen_range_inr
state_before: α : Type u
β : Type v
γ : Type ?u.140260
δ : Type ?u.140263
ε : Type ?u.140266
ζ : Type ?u.140269
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
⊢ IsOpen (range inr)
Theorem: EMetric.exists_pos_forall_lt_edist
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: rcases s.eq_empty_or_nonempty with (rfl | hne)
state_before: ι : Sort ?u.28317
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x y : α
s t : Set α
Φ : α → β
hs : IsCompact s
ht : IsClosed t
hst : Disjoint s t
⊢ ∃ r, 0 < r ∧ ∀ (x : α), x ∈ s → ∀ (y : α), y ∈ t → ↑r < edist x y

tactic: obtain ⟨x, hx, h⟩ : ∃ x ∈ s, ∀ y ∈ s, infEdist x t ≤ infEdist y t :=
  hs.exists_forall_le hne continuous_infEdist.continuousOn
state_before: case inr
ι : Sort ?u.28317
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x y : α
s t : Set α
Φ : α → β
hs : IsCompact s
ht : IsClosed t
hst : Disjoint s t
hne : Set.Nonempty s
⊢ ∃ r, 0 < r ∧ ∀ (x : α), x ∈ s → ∀ (y : α), y ∈ t → ↑r < edist x y

tactic: have : 0 < infEdist x t :=
  pos_iff_ne_zero.2 fun H => hst.le_bot ⟨hx, (mem_iff_infEdist_zero_of_closed ht).mpr H⟩
state_before: case inr.intro.intro
ι : Sort ?u.28317
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x✝ y : α
s t : Set α
Φ : α → β
hs : IsCompact s
ht : IsClosed t
hst : Disjoint s t
hne : Set.Nonempty s
x : α
hx : x ∈ s
h : ∀ (y : α), y ∈ s → infEdist x t ≤ infEdist y t
⊢ ∃ r, 0 < r ∧ ∀ (x : α), x ∈ s → ∀ (y : α), y ∈ t → ↑r < edist x y

tactic: rcases ENNReal.lt_iff_exists_nnreal_btwn.1 this with ⟨r, h₀, hr⟩
state_before: case inr.intro.intro
ι : Sort ?u.28317
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x✝ y : α
s t : Set α
Φ : α → β
hs : IsCompact s
ht : IsClosed t
hst : Disjoint s t
hne : Set.Nonempty s
x : α
hx : x ∈ s
h : ∀ (y : α), y ∈ s → infEdist x t ≤ infEdist y t
this : 0 < infEdist x t
⊢ ∃ r, 0 < r ∧ ∀ (x : α), x ∈ s → ∀ (y : α), y ∈ t → ↑r < edist x y

tactic: exact ⟨r, ENNReal.coe_pos.mp h₀, fun y hy z hz => hr.trans_le <| le_infEdist.1 (h y hy) z hz⟩
state_before: case inr.intro.intro.intro.intro
ι : Sort ?u.28317
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x✝ y : α
s t : Set α
Φ : α → β
hs : IsCompact s
ht : IsClosed t
hst : Disjoint s t
hne : Set.Nonempty s
x : α
hx : x ∈ s
h : ∀ (y : α), y ∈ s → infEdist x t ≤ infEdist y t
this : 0 < infEdist x t
r : ℝ≥0
h₀ : 0 < ↑r
hr : ↑r < infEdist x t
⊢ ∃ r, 0 < r ∧ ∀ (x : α), x ∈ s → ∀ (y : α), y ∈ t → ↑r < edist x y

tactic: use 1
state_before: case inl
ι : Sort ?u.28317
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x y : α
t : Set α
Φ : α → β
ht : IsClosed t
hs : IsCompact ∅
hst : Disjoint ∅ t
⊢ ∃ r, 0 < r ∧ ∀ (x : α), x ∈ ∅ → ∀ (y : α), y ∈ t → ↑r < edist x y

tactic: simp
state_before: case inl
ι : Sort ?u.28317
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x y : α
t : Set α
Φ : α → β
ht : IsClosed t
hs : IsCompact ∅
hst : Disjoint ∅ t
⊢ 0 < 1 ∧ ∀ (x : α), x ∈ ∅ → ∀ (y : α), y ∈ t → ↑1 < edist x y
Theorem: ClassGroup.mk_canonicalEquiv
File: Mathlib/RingTheory/ClassGroup.lean

tactic: rw [ClassGroup.mk, MonoidHom.comp_apply, ← MonoidHom.comp_apply (Units.map _), ← Units.map_comp, ←
    RingEquiv.coe_monoidHom_trans, FractionalIdeal.canonicalEquiv_trans_canonicalEquiv]
state_before: R : Type u_2
K : Type u_3
L : Type ?u.841605
inst✝¹³ : CommRing R
inst✝¹² : Field K
inst✝¹¹ : Field L
inst✝¹⁰ : DecidableEq L
inst✝⁹ : Algebra R K
inst✝⁸ : IsFractionRing R K
inst✝⁷ : Algebra K L
inst✝⁶ : FiniteDimensional K L
inst✝⁵ : Algebra R L
inst✝⁴ : IsScalarTower R K L
inst✝³ : IsDomain R
K' : Type u_1
inst✝² : Field K'
inst✝¹ : Algebra R K'
inst✝ : IsFractionRing R K'
I : (FractionalIdeal R⁰ K)ˣ
⊢ ↑mk (↑(Units.map ↑(canonicalEquiv R⁰ K K')) I) = ↑mk I

tactic: rfl
state_before: R : Type u_2
K : Type u_3
L : Type ?u.841605
inst✝¹³ : CommRing R
inst✝¹² : Field K
inst✝¹¹ : Field L
inst✝¹⁰ : DecidableEq L
inst✝⁹ : Algebra R K
inst✝⁸ : IsFractionRing R K
inst✝⁷ : Algebra K L
inst✝⁶ : FiniteDimensional K L
inst✝⁵ : Algebra R L
inst✝⁴ : IsScalarTower R K L
inst✝³ : IsDomain R
K' : Type u_1
inst✝² : Field K'
inst✝¹ : Algebra R K'
inst✝ : IsFractionRing R K'
I : (FractionalIdeal R⁰ K)ˣ
⊢ ↑(QuotientGroup.mk' (MonoidHom.range (toPrincipalIdeal R (FractionRing R))))
      (↑(Units.map ↑(canonicalEquiv R⁰ K (FractionRing R))) I) =
    ↑mk I
Theorem: Cardinal.aleph_le_beth
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: apply limitRecOn o
state_before: o : Ordinal
⊢ aleph o ≤ beth o

tactic: simp
state_before: case H₁
o : Ordinal
⊢ aleph 0 ≤ beth 0

tactic: intro o h
state_before: case H₂
o : Ordinal
⊢ ∀ (o : Ordinal), aleph o ≤ beth o → aleph (succ o) ≤ beth (succ o)

tactic: rw [aleph_succ, beth_succ, succ_le_iff]
state_before: case H₂
o✝ o : Ordinal
h : aleph o ≤ beth o
⊢ aleph (succ o) ≤ beth (succ o)

tactic: exact (cantor _).trans_le (power_le_power_left two_ne_zero h)
state_before: case H₂
o✝ o : Ordinal
h : aleph o ≤ beth o
⊢ aleph o < 2 ^ beth o

tactic: intro o ho IH
state_before: case H₃
o : Ordinal
⊢ ∀ (o : Ordinal), Ordinal.IsLimit o → (∀ (o' : Ordinal), o' < o → aleph o' ≤ beth o') → aleph o ≤ beth o

tactic: rw [aleph_limit ho, beth_limit ho]
state_before: case H₃
o✝ o : Ordinal
ho : Ordinal.IsLimit o
IH : ∀ (o' : Ordinal), o' < o → aleph o' ≤ beth o'
⊢ aleph o ≤ beth o

tactic: exact ciSup_mono (bddAbove_of_small _) fun x => IH x.1 x.2
state_before: case H₃
o✝ o : Ordinal
ho : Ordinal.IsLimit o
IH : ∀ (o' : Ordinal), o' < o → aleph o' ≤ beth o'
⊢ (⨆ (a : ↑(Iio o)), aleph ↑a) ≤ ⨆ (a : ↑(Iio o)), beth ↑a