tasksource/leandojo huggingface dataset:
Theorem: Polynomial.count_map_roots_of_injective
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: by_cases hp0 : p = 0
state_before: R : Type u
S : Type v
T : Type w
a b✝ : R
n : ℕ
A : Type u_1
B : Type u_2
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : IsDomain A
p : A[X]
f : A →+* B
hf : Function.Injective ↑f
b : B
⊢ Multiset.count b (Multiset.map (↑f) (roots p)) ≤ rootMultiplicity b (map f p)

tactic: simp only [hp0, roots_zero, Multiset.map_zero, Multiset.count_zero, Polynomial.map_zero,
  rootMultiplicity_zero]
state_before: case pos
R : Type u
S : Type v
T : Type w
a b✝ : R
n : ℕ
A : Type u_1
B : Type u_2
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : IsDomain A
p : A[X]
f : A →+* B
hf : Function.Injective ↑f
b : B
hp0 : p = 0
⊢ Multiset.count b (Multiset.map (↑f) (roots p)) ≤ rootMultiplicity b (map f p)

tactic: exact count_map_roots ((Polynomial.map_ne_zero_iff hf).mpr hp0) b
state_before: case neg
R : Type u
S : Type v
T : Type w
a b✝ : R
n : ℕ
A : Type u_1
B : Type u_2
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : IsDomain A
p : A[X]
f : A →+* B
hf : Function.Injective ↑f
b : B
hp0 : ¬p = 0
⊢ Multiset.count b (Multiset.map (↑f) (roots p)) ≤ rootMultiplicity b (map f p)
Theorem: Ordinal.lt_opow_of_limit
File: Mathlib/SetTheory/Ordinal/Exponential.lean

tactic: rw [← not_iff_not, not_exists]
state_before: a b c : Ordinal
b0 : b ≠ 0
h : IsLimit c
⊢ a < b ^ c ↔ ∃ c', c' < c ∧ a < b ^ c'

tactic: simp only [not_lt, opow_le_of_limit b0 h, exists_prop, not_and]
state_before: a b c : Ordinal
b0 : b ≠ 0
h : IsLimit c
⊢ ¬a < b ^ c ↔ ∀ (x : Ordinal), ¬(x < c ∧ a < b ^ x)
Theorem: SimpleGraph.fromEdgeSet_empty
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: ext (v w)
state_before: ι : Sort ?u.82740
𝕜 : Type ?u.82743
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e : Sym2 V
s : Set (Sym2 V)
⊢ fromEdgeSet ∅ = ⊥

tactic: simp only [fromEdgeSet_adj, Set.mem_empty_iff_false, false_and_iff, bot_adj]
state_before: case Adj.h.h.a
ι : Sort ?u.82740
𝕜 : Type ?u.82743
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v✝ w✝ : V
e : Sym2 V
s : Set (Sym2 V)
v w : V
⊢ Adj (fromEdgeSet ∅) v w ↔ Adj ⊥ v w
Theorem: Num.zero_add
File: Mathlib/Data/Num/Lemmas.lean

tactic: cases n <;> rfl
state_before: α : Type ?u.173311
n : Num
⊢ 0 + n = n
Theorem: CategoryTheory.Limits.coprod.diag_comp
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

tactic: simp
state_before: C : Type u
inst✝¹ : Category C
X✝ Y✝ X Y : C
inst✝ : HasBinaryCoproduct X X
f : X ⟶ Y
⊢ codiag X ≫ f = desc f f
Theorem: Real.log_le_sub_one_of_pos
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: rw [le_sub_iff_add_le]
state_before: x✝ y x : ℝ
hx : 0 < x
⊢ log x ≤ x - 1

tactic: convert add_one_le_exp (log x)
state_before: x✝ y x : ℝ
hx : 0 < x
⊢ log x + 1 ≤ x

tactic: rw [exp_log hx]
state_before: case h.e'_4
x✝ y x : ℝ
hx : 0 < x
⊢ x = exp (log x)
Theorem: LinearMap.IsSymm.isRefl
File: Mathlib/LinearAlgebra/SesquilinearForm.lean

tactic: rw [← H.eq]
state_before: R : Type u_1
R₁ : Type ?u.159549
R₂ : Type ?u.159552
R₃ : Type ?u.159555
M : Type u_2
M₁ : Type ?u.159561
M₂ : Type ?u.159564
Mₗ₁ : Type ?u.159567
Mₗ₁' : Type ?u.159570
Mₗ₂ : Type ?u.159573
Mₗ₂' : Type ?u.159576
K : Type ?u.159579
K₁ : Type ?u.159582
K₂ : Type ?u.159585
V : Type ?u.159588
V₁ : Type ?u.159591
V₂ : Type ?u.159594
n : Type ?u.159597
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
I : R →+* R
B : M →ₛₗ[I] M →ₗ[R] R
H : IsSymm B
x y : M
H1 : ↑(↑B x) y = 0
⊢ ↑(↑B y) x = 0

tactic: simp [H1]
state_before: R : Type u_1
R₁ : Type ?u.159549
R₂ : Type ?u.159552
R₃ : Type ?u.159555
M : Type u_2
M₁ : Type ?u.159561
M₂ : Type ?u.159564
Mₗ₁ : Type ?u.159567
Mₗ₁' : Type ?u.159570
Mₗ₂ : Type ?u.159573
Mₗ₂' : Type ?u.159576
K : Type ?u.159579
K₁ : Type ?u.159582
K₂ : Type ?u.159585
V : Type ?u.159588
V₁ : Type ?u.159591
V₂ : Type ?u.159594
n : Type ?u.159597
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
I : R →+* R
B : M →ₛₗ[I] M →ₗ[R] R
H : IsSymm B
x y : M
H1 : ↑(↑B x) y = 0
⊢ ↑I (↑(↑B x) y) = 0
Theorem: mem_closure_one_iff_norm
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: rw [← closedBall_zero', mem_closedBall_one_iff, (norm_nonneg' x).le_iff_eq]
state_before: 𝓕 : Type ?u.463871
𝕜 : Type ?u.463874
α : Type ?u.463877
ι : Type ?u.463880
κ : Type ?u.463883
E : Type u_1
F : Type ?u.463889
G : Type ?u.463892
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
x : E
⊢ x ∈ closure {1} ↔ ‖x‖ = 0
Theorem: Filter.prod_map_left
File: Mathlib/Order/Filter/Prod.lean

tactic: rw [← prod_map_map_eq', map_id]
state_before: α : Type u_1
β : Type u_3
γ : Type u_2
δ : Type ?u.28728
ι : Sort ?u.28731
s : Set α
t : Set β
f✝ : Filter α
g : Filter β
f : α → β
F : Filter α
G : Filter γ
⊢ map f F ×ˢ G = map (Prod.map f id) (F ×ˢ G)
Theorem: isPrimePow_nat_iff
File: Mathlib/Algebra/IsPrimePow.lean

tactic: simp only [isPrimePow_def, Nat.prime_iff]
state_before: R : Type ?u.81638
inst✝ : CommMonoidWithZero R
n✝ p : R
k n : ℕ
⊢ IsPrimePow n ↔ ∃ p k, Nat.Prime p ∧ 0 < k ∧ p ^ k = n
Theorem: Fintype.finsetEquivSet_symm_apply
File: Mathlib/Data/Fintype/Basic.lean

tactic: simp [finsetEquivSet]
state_before: α : Type u_1
β : Type ?u.136843
γ : Type ?u.136846
inst✝¹ : Fintype α
s : Set α
inst✝ : Fintype ↑s
⊢ ↑finsetEquivSet.symm s = Set.toFinset s

tactic: congr
state_before: α : Type u_1
β : Type ?u.136843
γ : Type ?u.136846
inst✝¹ : Fintype α
s : Set α
inst✝ : Fintype ↑s
⊢ Set.toFinset s = Set.toFinset s

tactic: exact Subsingleton.elim _ _
state_before: case h.e_3.h
α : Type u_1
β : Type ?u.136843
γ : Type ?u.136846
inst✝¹ : Fintype α
s : Set α
inst✝ : Fintype ↑s
⊢ (Subtype.fintype fun x => x ∈ s) = inst✝
Theorem: LocalHomeomorph.subtypeRestr_source
File: Mathlib/Topology/LocalHomeomorph.lean

tactic: simp only [subtypeRestr_def, mfld_simps]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.115242
δ : Type ?u.115245
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
e : LocalHomeomorph α β
s : Opens α
inst✝ : Nonempty { x // x ∈ s }
⊢ (subtypeRestr e s).toLocalEquiv.source = Subtype.val ⁻¹' e.source
Theorem: EMetric.inseparable_iff
File: Mathlib/Topology/MetricSpace/EMetricSpace.lean

tactic: simp [inseparable_iff_mem_closure, mem_closure_iff, edist_comm, forall_lt_iff_le']
state_before: α : Type u
β : Type v
X : Type ?u.226694
inst✝ : PseudoEMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ≥0∞
s t : Set α
⊢ Inseparable x y ↔ edist x y = 0
Theorem: Option.map_bind
File: Mathlib/Data/Option/Basic.lean

tactic: simp only [← map_eq_map, ← bind_pure_comp, LawfulMonad.bind_assoc]
state_before: α✝ : Type ?u.5024
β✝ : Type ?u.5027
γ✝ : Type ?u.5030
δ : Type ?u.5033
p : α✝ → Prop
f✝ : (a : α✝) → p a → β✝
x✝ : Option α✝
α β γ : Type u_1
f : β → γ
x : Option α
g : α → Option β
⊢ Option.map f (x >>= g) = do
    let a ← x
    Option.map f (g a)
Theorem: Ordinal.add_le_of_forall_add_lt
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: have H : a + (c - a) = c :=
  Ordinal.add_sub_cancel_of_le
    (by
      rw [← add_zero a]
      exact (h _ hb).le)
state_before: a b c : Ordinal
hb : 0 < b
h : ∀ (d : Ordinal), d < b → a + d < c
⊢ a + b ≤ c

tactic: rw [← H]
state_before: a b c : Ordinal
hb : 0 < b
h : ∀ (d : Ordinal), d < b → a + d < c
H : a + (c - a) = c
⊢ a + b ≤ c

tactic: apply add_le_add_left _ a
state_before: a b c : Ordinal
hb : 0 < b
h : ∀ (d : Ordinal), d < b → a + d < c
H : a + (c - a) = c
⊢ a + b ≤ a + (c - a)

tactic: by_contra' hb
state_before: a b c : Ordinal
hb : 0 < b
h : ∀ (d : Ordinal), d < b → a + d < c
H : a + (c - a) = c
⊢ b ≤ c - a

tactic: exact (h _ hb).ne H
state_before: a b c : Ordinal
hb✝ : 0 < b
h : ∀ (d : Ordinal), d < b → a + d < c
H : a + (c - a) = c
hb : c - a < b
⊢ False

tactic: rw [← add_zero a]
state_before: a b c : Ordinal
hb : 0 < b
h : ∀ (d : Ordinal), d < b → a + d < c
⊢ a ≤ c

tactic: exact (h _ hb).le
state_before: a b c : Ordinal
hb : 0 < b
h : ∀ (d : Ordinal), d < b → a + d < c
⊢ a + 0 ≤ c
Theorem: SimpleGraph.Walk.append_copy_copy
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: subst_vars
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w u' v' w' : V
p : Walk G u v
q : Walk G v w
hu : u = u'
hv : v = v'
hw : w = w'
⊢ append (Walk.copy p hu hv) (Walk.copy q hv hw) = Walk.copy (append p q) hu hw

tactic: rfl
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u' v' w' : V
p : Walk G u' v'
q : Walk G v' w'
⊢ append (Walk.copy p (_ : u' = u') (_ : v' = v')) (Walk.copy q (_ : v' = v') (_ : w' = w')) =
    Walk.copy (append p q) (_ : u' = u') (_ : w' = w')
Theorem: IsPreconnected.eq_or_eq_neg_of_sq_eq
File: Mathlib/Topology/Algebra/Field.lean

tactic: have hsq : EqOn ((f / g) ^ 2) 1 S := fun x hx => by
  simpa [div_eq_one_iff_eq (pow_ne_zero _ (hg_ne hx))] using hsq hx
state_before: K : Type ?u.21895
inst✝⁷ : DivisionRing K
inst✝⁶ : TopologicalSpace K
α : Type u_2
𝕜 : Type u_1
f g : α → 𝕜
S : Set α
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : T1Space 𝕜
inst✝² : Field 𝕜
inst✝¹ : HasContinuousInv₀ 𝕜
inst✝ : ContinuousMul 𝕜
hS : IsPreconnected S
hf : ContinuousOn f S
hg : ContinuousOn g S
hsq : EqOn (f ^ 2) (g ^ 2) S
hg_ne : ∀ {x : α}, x ∈ S → g x ≠ 0
⊢ EqOn f g S ∨ EqOn f (-g) S

tactic: simpa (config := { contextual := true }) [EqOn, div_eq_iff (hg_ne _)]
  using hS.eq_one_or_eq_neg_one_of_sq_eq (hf.div hg fun z => hg_ne) hsq
state_before: K : Type ?u.21895
inst✝⁷ : DivisionRing K
inst✝⁶ : TopologicalSpace K
α : Type u_2
𝕜 : Type u_1
f g : α → 𝕜
S : Set α
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : T1Space 𝕜
inst✝² : Field 𝕜
inst✝¹ : HasContinuousInv₀ 𝕜
inst✝ : ContinuousMul 𝕜
hS : IsPreconnected S
hf : ContinuousOn f S
hg : ContinuousOn g S
hsq✝ : EqOn (f ^ 2) (g ^ 2) S
hg_ne : ∀ {x : α}, x ∈ S → g x ≠ 0
hsq : EqOn ((f / g) ^ 2) 1 S
⊢ EqOn f g S ∨ EqOn f (-g) S

tactic: simpa [div_eq_one_iff_eq (pow_ne_zero _ (hg_ne hx))] using hsq hx
state_before: K : Type ?u.21895
inst✝⁷ : DivisionRing K
inst✝⁶ : TopologicalSpace K
α : Type u_2
𝕜 : Type u_1
f g : α → 𝕜
S : Set α
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : T1Space 𝕜
inst✝² : Field 𝕜
inst✝¹ : HasContinuousInv₀ 𝕜
inst✝ : ContinuousMul 𝕜
hS : IsPreconnected S
hf : ContinuousOn f S
hg : ContinuousOn g S
hsq : EqOn (f ^ 2) (g ^ 2) S
hg_ne : ∀ {x : α}, x ∈ S → g x ≠ 0
x : α
hx : x ∈ S
⊢ ((f / g) ^ 2) x = OfNat.ofNat 1 x
Theorem: Nat.prod_pow_prime_padicValNat
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: conv =>
  rhs
  rw [← factorization_prod_pow_eq_self hn]
state_before: n : ℕ
hn : n ≠ 0
m : ℕ
pr : n < m
⊢ ∏ p in Finset.filter Prime (Finset.range m), p ^ padicValNat p n = n

tactic: rw [eq_comm]
state_before: n : ℕ
hn : n ≠ 0
m : ℕ
pr : n < m
⊢ ∏ p in Finset.filter Prime (Finset.range m), p ^ padicValNat p n = Finsupp.prod (factorization n) fun x x_1 => x ^ x_1

tactic: apply Finset.prod_subset_one_on_sdiff
state_before: n : ℕ
hn : n ≠ 0
m : ℕ
pr : n < m
⊢ (Finsupp.prod (factorization n) fun x x_1 => x ^ x_1) =
    ∏ p in Finset.filter Prime (Finset.range m), p ^ padicValNat p n

tactic: exact fun p hp =>
  Finset.mem_filter.mpr
    ⟨Finset.mem_range.mpr (gt_of_gt_of_ge pr (le_of_mem_factorization hp)),
      prime_of_mem_factorization hp⟩
state_before: case h
n : ℕ
hn : n ≠ 0
m : ℕ
pr : n < m
⊢ (factorization n).support ⊆ Finset.filter Prime (Finset.range m)

tactic: intro p hp
state_before: case hg
n : ℕ
hn : n ≠ 0
m : ℕ
pr : n < m
⊢ ∀ (x : ℕ), x ∈ Finset.filter Prime (Finset.range m) \ (factorization n).support → x ^ padicValNat x n = 1

tactic: cases' Finset.mem_sdiff.mp hp with hp1 hp2
state_before: case hg
n : ℕ
hn : n ≠ 0
m : ℕ
pr : n < m
p : ℕ
hp : p ∈ Finset.filter Prime (Finset.range m) \ (factorization n).support
⊢ p ^ padicValNat p n = 1

tactic: rw [← factorization_def n (Finset.mem_filter.mp hp1).2]
state_before: case hg.intro
n : ℕ
hn : n ≠ 0
m : ℕ
pr : n < m
p : ℕ
hp : p ∈ Finset.filter Prime (Finset.range m) \ (factorization n).support
hp1 : p ∈ Finset.filter Prime (Finset.range m)
hp2 : ¬p ∈ (factorization n).support
⊢ p ^ padicValNat p n = 1

tactic: simp [Finsupp.not_mem_support_iff.mp hp2]
state_before: case hg.intro
n : ℕ
hn : n ≠ 0
m : ℕ
pr : n < m
p : ℕ
hp : p ∈ Finset.filter Prime (Finset.range m) \ (factorization n).support
hp1 : p ∈ Finset.filter Prime (Finset.range m)
hp2 : ¬p ∈ (factorization n).support
⊢ p ^ ↑(factorization n) p = 1

tactic: intro p hp
state_before: case hfg
n : ℕ
hn : n ≠ 0
m : ℕ
pr : n < m
⊢ ∀ (x : ℕ), x ∈ (factorization n).support → (fun x x_1 => x ^ x_1) x (↑(factorization n) x) = x ^ padicValNat x n

tactic: simp [factorization_def n (prime_of_mem_factorization hp)]
state_before: case hfg
n : ℕ
hn : n ≠ 0
m : ℕ
pr : n < m
p : ℕ
hp : p ∈ (factorization n).support
⊢ (fun x x_1 => x ^ x_1) p (↑(factorization n) p) = p ^ padicValNat p n
Theorem: Ctop.Realizer.is_basis
File: Mathlib/Data/Analysis/Topology.lean

tactic: have := toTopsp_isTopologicalBasis F.F
state_before: α : Type u_1
β : Type ?u.7918
σ : Type ?u.7921
τ : Type ?u.7924
T : TopologicalSpace α
F : Realizer α
⊢ TopologicalSpace.IsTopologicalBasis (range F.F.f)

tactic: rwa [F.eq] at this
state_before: α : Type u_1
β : Type ?u.7918
σ : Type ?u.7921
τ : Type ?u.7924
T : TopologicalSpace α
F : Realizer α
this : TopologicalSpace.IsTopologicalBasis (range F.F.f)
⊢ TopologicalSpace.IsTopologicalBasis (range F.F.f)
Theorem: Nat.one_lt_two_pow
File: Mathlib/Data/Nat/Pow.lean

tactic: decide
state_before: n : ℕ
h₀ : 0 < n
⊢ 1 < 2
Theorem: CategoryTheory.Limits.hasLimitOfIso
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

tactic: rw [Cones.postcompose_obj_π, NatTrans.comp_app, limit.cone_π, ← Category.assoc,
  limit.lift_π]
state_before: J : Type u₁
inst✝³ : Category J
K : Type u₂
inst✝² : Category K
C : Type u
inst✝¹ : Category C
F✝ F G : J ⥤ C
inst✝ : HasLimit F
α : F ≅ G
s : Cone G
j : J
⊢ (fun s => limit.lift F ((Cones.postcompose α.inv).obj s)) s ≫ ((Cones.postcompose α.hom).obj (limit.cone F)).π.app j =
    s.π.app j

tactic: simp
state_before: J : Type u₁
inst✝³ : Category J
K : Type u₂
inst✝² : Category K
C : Type u
inst✝¹ : Category C
F✝ F G : J ⥤ C
inst✝ : HasLimit F
α : F ≅ G
s : Cone G
j : J
⊢ ((Cones.postcompose α.inv).obj s).π.app j ≫ α.hom.app j = s.π.app j

tactic: apply limit.hom_ext
state_before: J : Type u₁
inst✝³ : Category J
K : Type u₂
inst✝² : Category K
C : Type u
inst✝¹ : Category C
F✝ F G : J ⥤ C
inst✝ : HasLimit F
α : F ≅ G
s : Cone G
m : s.pt ⟶ ((Cones.postcompose α.hom).obj (limit.cone F)).pt
w : ∀ (j : J), m ≫ ((Cones.postcompose α.hom).obj (limit.cone F)).π.app j = s.π.app j
⊢ m = (fun s => limit.lift F ((Cones.postcompose α.inv).obj s)) s

tactic: intro j
state_before: case w
J : Type u₁
inst✝³ : Category J
K : Type u₂
inst✝² : Category K
C : Type u
inst✝¹ : Category C
F✝ F G : J ⥤ C
inst✝ : HasLimit F
α : F ≅ G
s : Cone G
m : s.pt ⟶ ((Cones.postcompose α.hom).obj (limit.cone F)).pt
w : ∀ (j : J), m ≫ ((Cones.postcompose α.hom).obj (limit.cone F)).π.app j = s.π.app j
⊢ ∀ (j : J), m ≫ limit.π F j = (fun s => limit.lift F ((Cones.postcompose α.inv).obj s)) s ≫ limit.π F j

tactic: rw [limit.lift_π, Cones.postcompose_obj_π, NatTrans.comp_app, ← NatIso.app_inv,
  Iso.eq_comp_inv]
state_before: case w
J : Type u₁
inst✝³ : Category J
K : Type u₂
inst✝² : Category K
C : Type u
inst✝¹ : Category C
F✝ F G : J ⥤ C
inst✝ : HasLimit F
α : F ≅ G
s : Cone G
m : s.pt ⟶ ((Cones.postcompose α.hom).obj (limit.cone F)).pt
w : ∀ (j : J), m ≫ ((Cones.postcompose α.hom).obj (limit.cone F)).π.app j = s.π.app j
j : J
⊢ m ≫ limit.π F j = (fun s => limit.lift F ((Cones.postcompose α.inv).obj s)) s ≫ limit.π F j

tactic: simpa using w j
state_before: case w
J : Type u₁
inst✝³ : Category J
K : Type u₂
inst✝² : Category K
C : Type u
inst✝¹ : Category C
F✝ F G : J ⥤ C
inst✝ : HasLimit F
α : F ≅ G
s : Cone G
m : s.pt ⟶ ((Cones.postcompose α.hom).obj (limit.cone F)).pt
w : ∀ (j : J), m ≫ ((Cones.postcompose α.hom).obj (limit.cone F)).π.app j = s.π.app j
j : J
⊢ (m ≫ limit.π F j) ≫ (α.app j).hom = s.π.app j
Theorem: isSimpleModule_iff_isAtom
File: Mathlib/RingTheory/SimpleModule.lean

tactic: rw [← Set.isSimpleOrder_Iic_iff_isAtom]
state_before: R : Type u_1
inst✝⁴ : Ring R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
m : Submodule R M
N : Type ?u.14646
inst✝¹ : AddCommGroup N
inst✝ : Module R N
⊢ IsSimpleModule R { x // x ∈ m } ↔ IsAtom m

tactic: apply OrderIso.isSimpleOrder_iff
state_before: R : Type u_1
inst✝⁴ : Ring R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
m : Submodule R M
N : Type ?u.14646
inst✝¹ : AddCommGroup N
inst✝ : Module R N
⊢ IsSimpleModule R { x // x ∈ m } ↔ IsSimpleOrder ↑(Set.Iic m)

tactic: exact Submodule.MapSubtype.relIso m
state_before: case f
R : Type u_1
inst✝⁴ : Ring R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
m : Submodule R M
N : Type ?u.14646
inst✝¹ : AddCommGroup N
inst✝ : Module R N
⊢ Submodule R { x // x ∈ m } ≃o ↑(Set.Iic m)
Theorem: finiteDimensional_of_rank_eq_nat
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

tactic: rw [FiniteDimensional, ← IsNoetherian.iff_fg, IsNoetherian.iff_rank_lt_aleph0, h]
state_before: K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
n : ℕ
h : Module.rank K V = ↑n
⊢ FiniteDimensional K V

tactic: exact nat_lt_aleph0 n
state_before: K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
n : ℕ
h : Module.rank K V = ↑n
⊢ ↑n < ℵ₀
Theorem: Polynomial.ne_zero_of_mem_rootSet
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: rwa [hf, rootSet_zero] at h
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]
inst✝² : CommRing S
inst✝¹ : IsDomain S
inst✝ : Algebra T S
a : S
h : a ∈ rootSet p S
hf : p = 0
⊢ False
Theorem: Matrix.Pivot.listTransvecCol_mul_last_row
File: Mathlib/LinearAlgebra/Matrix/Transvection.lean

tactic: simpa using listTransvecCol_mul_last_row_drop M i (zero_le _)
state_before: n : Type ?u.155183
p : Type ?u.155186
R : Type u₂
𝕜 : Type u_1
inst✝³ : Field 𝕜
inst✝² : DecidableEq n
inst✝¹ : DecidableEq p
inst✝ : CommRing R
r : ℕ
M : Matrix (Fin r ⊕ Unit) (Fin r ⊕ Unit) 𝕜
i : Fin r ⊕ Unit
⊢ (List.prod (listTransvecCol M) ⬝ M) (inr ()) i = M (inr ()) i
Theorem: MeasureTheory.measure_eq_trim
File: Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean

tactic: rw [μ.trimmed]
state_before: α : Type u_1
β : Type ?u.10446
γ : Type ?u.10449
δ : Type ?u.10452
ι : Type ?u.10455
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t s : Set α
⊢ ↑↑μ s = ↑(OuterMeasure.trim ↑μ) s
Theorem: LinearPMap.mkSpanSingleton'_apply
File: Mathlib/LinearAlgebra/LinearPMap.lean

tactic: dsimp [mkSpanSingleton']
state_before: R : Type u_2
inst✝⁶ : Ring R
E : Type u_1
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.69603
inst✝¹ : AddCommGroup G
inst✝ : Module R G
x : E
y : F
H : ∀ (c : R), c • x = 0 → c • y = 0
c : R
h : c • x ∈ (mkSpanSingleton' x y H).domain
⊢ ↑(mkSpanSingleton' x y H) { val := c • x, property := h } = c • y

tactic: rw [← sub_eq_zero, ← sub_smul]
state_before: R : Type u_2
inst✝⁶ : Ring R
E : Type u_1
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.69603
inst✝¹ : AddCommGroup G
inst✝ : Module R G
x : E
y : F
H : ∀ (c : R), c • x = 0 → c • y = 0
c : R
h : c • x ∈ (mkSpanSingleton' x y H).domain
⊢ Classical.choose (_ : ∃ a, a • x = c • x) • y = c • y

tactic: apply H
state_before: R : Type u_2
inst✝⁶ : Ring R
E : Type u_1
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.69603
inst✝¹ : AddCommGroup G
inst✝ : Module R G
x : E
y : F
H : ∀ (c : R), c • x = 0 → c • y = 0
c : R
h : c • x ∈ (mkSpanSingleton' x y H).domain
⊢ (Classical.choose (_ : ∃ a, a • x = c • x) - c) • y = 0

tactic: simp only [sub_smul, one_smul, sub_eq_zero]
state_before: case a
R : Type u_2
inst✝⁶ : Ring R
E : Type u_1
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.69603
inst✝¹ : AddCommGroup G
inst✝ : Module R G
x : E
y : F
H : ∀ (c : R), c • x = 0 → c • y = 0
c : R
h : c • x ∈ (mkSpanSingleton' x y H).domain
⊢ (Classical.choose (_ : ∃ a, a • x = c • x) - c) • x = 0

tactic: apply Classical.choose_spec (mem_span_singleton.1 h)
state_before: case a
R : Type u_2
inst✝⁶ : Ring R
E : Type u_1
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.69603
inst✝¹ : AddCommGroup G
inst✝ : Module R G
x : E
y : F
H : ∀ (c : R), c • x = 0 → c • y = 0
c : R
h : c • x ∈ (mkSpanSingleton' x y H).domain
⊢ Classical.choose (_ : ∃ a, a • x = c • x) • x = c • x
Theorem: CategoryTheory.IsFiltered.bowtie
File: Mathlib/CategoryTheory/Filtered.lean

tactic: obtain ⟨t, k₁t, k₂t, ht⟩ := span f₁ g₁
state_before: C : Type u
inst✝¹ : Category C
inst✝ : IsFilteredOrEmpty C
j₁ j₂ k₁ k₂ : C
f₁ : j₁ ⟶ k₁
g₁ : j₁ ⟶ k₂
f₂ : j₂ ⟶ k₁
g₂ : j₂ ⟶ k₂
⊢ ∃ s α β, f₁ ≫ α = g₁ ≫ β ∧ f₂ ≫ α = g₂ ≫ β

tactic: obtain ⟨s, ts, hs⟩ := IsFilteredOrEmpty.cocone_maps (f₂ ≫ k₁t) (g₂ ≫ k₂t)
state_before: case intro.intro.intro
C : Type u
inst✝¹ : Category C
inst✝ : IsFilteredOrEmpty C
j₁ j₂ k₁ k₂ : C
f₁ : j₁ ⟶ k₁
g₁ : j₁ ⟶ k₂
f₂ : j₂ ⟶ k₁
g₂ : j₂ ⟶ k₂
t : C
k₁t : k₁ ⟶ t
k₂t : k₂ ⟶ t
ht : f₁ ≫ k₁t = g₁ ≫ k₂t
⊢ ∃ s α β, f₁ ≫ α = g₁ ≫ β ∧ f₂ ≫ α = g₂ ≫ β

tactic: simp_rw [Category.assoc] at hs
state_before: case intro.intro.intro.intro.intro
C : Type u
inst✝¹ : Category C
inst✝ : IsFilteredOrEmpty C
j₁ j₂ k₁ k₂ : C
f₁ : j₁ ⟶ k₁
g₁ : j₁ ⟶ k₂
f₂ : j₂ ⟶ k₁
g₂ : j₂ ⟶ k₂
t : C
k₁t : k₁ ⟶ t
k₂t : k₂ ⟶ t
ht : f₁ ≫ k₁t = g₁ ≫ k₂t
s : C
ts : t ⟶ s
hs : (f₂ ≫ k₁t) ≫ ts = (g₂ ≫ k₂t) ≫ ts
⊢ ∃ s α β, f₁ ≫ α = g₁ ≫ β ∧ f₂ ≫ α = g₂ ≫ β

tactic: exact ⟨s, k₁t ≫ ts, k₂t ≫ ts, by simp only [←Category.assoc, ht], hs⟩
state_before: case intro.intro.intro.intro.intro
C : Type u
inst✝¹ : Category C
inst✝ : IsFilteredOrEmpty C
j₁ j₂ k₁ k₂ : C
f₁ : j₁ ⟶ k₁
g₁ : j₁ ⟶ k₂
f₂ : j₂ ⟶ k₁
g₂ : j₂ ⟶ k₂
t : C
k₁t : k₁ ⟶ t
k₂t : k₂ ⟶ t
ht : f₁ ≫ k₁t = g₁ ≫ k₂t
s : C
ts : t ⟶ s
hs : f₂ ≫ k₁t ≫ ts = g₂ ≫ k₂t ≫ ts
⊢ ∃ s α β, f₁ ≫ α = g₁ ≫ β ∧ f₂ ≫ α = g₂ ≫ β

tactic: simp only [←Category.assoc, ht]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : IsFilteredOrEmpty C
j₁ j₂ k₁ k₂ : C
f₁ : j₁ ⟶ k₁
g₁ : j₁ ⟶ k₂
f₂ : j₂ ⟶ k₁
g₂ : j₂ ⟶ k₂
t : C
k₁t : k₁ ⟶ t
k₂t : k₂ ⟶ t
ht : f₁ ≫ k₁t = g₁ ≫ k₂t
s : C
ts : t ⟶ s
hs : f₂ ≫ k₁t ≫ ts = g₂ ≫ k₂t ≫ ts
⊢ f₁ ≫ k₁t ≫ ts = g₁ ≫ k₂t ≫ ts
Theorem: Set.prod_sub_preimage_iff
File: Mathlib/Data/Set/Prod.lean

tactic: simp [subset_def]
state_before: α : Type u_2
β : Type u_3
γ : Type u_1
δ : Type ?u.80055
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
W : Set γ
f : α × β → γ
⊢ s ×ˢ t ⊆ f ⁻¹' W ↔ ∀ (a : α) (b : β), a ∈ s → b ∈ t → f (a, b) ∈ W