tasksource/leandojo huggingface dataset:
Theorem: Basis.dual_rank_eq
File: Mathlib/LinearAlgebra/Dual.lean

tactic: classical
  cases nonempty_fintype ι
  have := LinearEquiv.lift_rank_eq b.toDualEquiv
  rw [Cardinal.lift_umax.{u₂,u₁}] at this
  rw [this, ← Cardinal.lift_umax]
  apply Cardinal.lift_id
state_before: R : Type u
M : Type v
K : Type u₁
V : Type u₂
ι : Type w
inst✝³ : CommRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : _root_.Finite ι
b : Basis ι K V
⊢ lift (Module.rank K V) = Module.rank K (Dual K V)

tactic: cases nonempty_fintype ι
state_before: R : Type u
M : Type v
K : Type u₁
V : Type u₂
ι : Type w
inst✝³ : CommRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : _root_.Finite ι
b : Basis ι K V
⊢ lift (Module.rank K V) = Module.rank K (Dual K V)

tactic: have := LinearEquiv.lift_rank_eq b.toDualEquiv
state_before: case intro
R : Type u
M : Type v
K : Type u₁
V : Type u₂
ι : Type w
inst✝³ : CommRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : _root_.Finite ι
b : Basis ι K V
val✝ : Fintype ι
⊢ lift (Module.rank K V) = Module.rank K (Dual K V)

tactic: rw [Cardinal.lift_umax.{u₂,u₁}] at this
state_before: case intro
R : Type u
M : Type v
K : Type u₁
V : Type u₂
ι : Type w
inst✝³ : CommRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : _root_.Finite ι
b : Basis ι K V
val✝ : Fintype ι
this : lift (Module.rank K V) = lift (Module.rank K (Dual K V))
⊢ lift (Module.rank K V) = Module.rank K (Dual K V)

tactic: rw [this, ← Cardinal.lift_umax]
state_before: case intro
R : Type u
M : Type v
K : Type u₁
V : Type u₂
ι : Type w
inst✝³ : CommRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : _root_.Finite ι
b : Basis ι K V
val✝ : Fintype ι
this : lift (Module.rank K V) = lift (Module.rank K (Dual K V))
⊢ lift (Module.rank K V) = Module.rank K (Dual K V)

tactic: apply Cardinal.lift_id
state_before: case intro
R : Type u
M : Type v
K : Type u₁
V : Type u₂
ι : Type w
inst✝³ : CommRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : _root_.Finite ι
b : Basis ι K V
val✝ : Fintype ι
this : lift (Module.rank K V) = lift (Module.rank K (Dual K V))
⊢ lift (Module.rank K (Dual K V)) = Module.rank K (Dual K V)
Theorem: MeasureTheory.ae_restrict_uIoc_iff
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [ae_restrict_uIoc_eq, eventually_sup]
state_before: α : Type u_1
β : Type ?u.566270
γ : Type ?u.566273
δ : Type ?u.566276
ι : Type ?u.566279
R : Type ?u.566282
R' : Type ?u.566285
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : LinearOrder α
a b : α
P : α → Prop
⊢ (∀ᵐ (x : α) ∂Measure.restrict μ (Ι a b), P x) ↔
    (∀ᵐ (x : α) ∂Measure.restrict μ (Ioc a b), P x) ∧ ∀ᵐ (x : α) ∂Measure.restrict μ (Ioc b a), P x
Theorem: Set.preimage_inl_image_inr
File: Mathlib/Data/Set/Image.lean

tactic: ext
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.83955
ι : Sort ?u.83958
ι' : Sort ?u.83961
f : ι → α
s✝ t : Set α
s : Set β
⊢ Sum.inl ⁻¹' (Sum.inr '' s) = ∅

tactic: simp
state_before: case h
α : Type u_2
β : Type u_1
γ : Type ?u.83955
ι : Sort ?u.83958
ι' : Sort ?u.83961
f : ι → α
s✝ t : Set α
s : Set β
x✝ : α
⊢ x✝ ∈ Sum.inl ⁻¹' (Sum.inr '' s) ↔ x✝ ∈ ∅
Theorem: Polynomial.leadingCoeff_X_add_C
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: rw [← pow_one (X : S[X]), leadingCoeff_X_pow_add_C zero_lt_one]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝¹ : Semiring R
inst✝ : Semiring S
r : S
⊢ leadingCoeff (X + ↑C r) = 1
Theorem: Function.Surjective.lieAlgebra_isNilpotent
File: Mathlib/Algebra/Lie/Nilpotent.lean

tactic: obtain ⟨k, hk⟩ := id h₁
state_before: R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
h₁ : LieAlgebra.IsNilpotent R L
f : L →ₗ⁅R⁆ L'
h₂ : Surjective ↑f
⊢ ∃ k, lowerCentralSeries R L' L' k = ⊥

tactic: use k
state_before: case mk.intro
R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
h₁ : LieAlgebra.IsNilpotent R L
f : L →ₗ⁅R⁆ L'
h₂ : Surjective ↑f
k : ℕ
hk : lowerCentralSeries R L L k = ⊥
⊢ ∃ k, lowerCentralSeries R L' L' k = ⊥

tactic: rw [← LieIdeal.lowerCentralSeries_map_eq k h₂, hk]
state_before: case mk.intro
R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
h₁ : LieAlgebra.IsNilpotent R L
f : L →ₗ⁅R⁆ L'
h₂ : Surjective ↑f
k : ℕ
hk : lowerCentralSeries R L L k = ⊥
⊢ lowerCentralSeries R L' L' k = ⊥

tactic: simp only [LieIdeal.map_eq_bot_iff, bot_le]
state_before: case mk.intro
R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
h₁ : LieAlgebra.IsNilpotent R L
f : L →ₗ⁅R⁆ L'
h₂ : Surjective ↑f
k : ℕ
hk : lowerCentralSeries R L L k = ⊥
⊢ LieIdeal.map f ⊥ = ⊥
Theorem: Nat.choose_le_pow
File: Mathlib/Data/Nat/Choose/Bounds.lean

tactic: rw [le_div_iff']
state_before: α : Type u_1
inst✝ : LinearOrderedSemifield α
r n : ℕ
⊢ ↑(choose n r) ≤ ↑(n ^ r) / ↑r !

tactic: exact_mod_cast r.factorial_pos
state_before: α : Type u_1
inst✝ : LinearOrderedSemifield α
r n : ℕ
⊢ 0 < ↑r !

tactic: norm_cast
state_before: α : Type u_1
inst✝ : LinearOrderedSemifield α
r n : ℕ
⊢ ↑r ! * ↑(choose n r) ≤ ↑(n ^ r)

tactic: rw [← Nat.descFactorial_eq_factorial_mul_choose]
state_before: α : Type u_1
inst✝ : LinearOrderedSemifield α
r n : ℕ
⊢ r ! * choose n r ≤ n ^ r

tactic: exact n.descFactorial_le_pow r
state_before: α : Type u_1
inst✝ : LinearOrderedSemifield α
r n : ℕ
⊢ descFactorial n r ≤ n ^ r
Theorem: IntermediateField.rank_eq_one_iff
File: Mathlib/FieldTheory/Adjoin.lean

tactic: rw [← toSubalgebra_eq_iff, ← rank_eq_rank_subalgebra, Subalgebra.rank_eq_one_iff,
  bot_toSubalgebra]
state_before: F : Type u_2
inst✝² : Field F
E : Type u_1
inst✝¹ : Field E
inst✝ : Algebra F E
α : E
S : Set E
K L : IntermediateField F E
⊢ Module.rank F { x // x ∈ K } = 1 ↔ K = ⊥
Theorem: Fin.heq_ext_iff
File: Mathlib/Data/Fin/Basic.lean

tactic: subst h
state_before: n m k l : ℕ
h : k = l
i : Fin k
j : Fin l
⊢ HEq i j ↔ ↑i = ↑j

tactic: simp [val_eq_val]
state_before: n m k : ℕ
i j : Fin k
⊢ HEq i j ↔ ↑i = ↑j
Theorem: Nat.log_monotone
File: Mathlib/Data/Nat/Log.lean

tactic: refine' monotone_nat_of_le_succ fun n => _
state_before: b : ℕ
⊢ Monotone (log b)

tactic: cases' le_or_lt b 1 with hb hb
state_before: b n : ℕ
⊢ log b n ≤ log b (n + 1)

tactic: rw [log_of_left_le_one hb]
state_before: case inl
b n : ℕ
hb : b ≤ 1
⊢ log b n ≤ log b (n + 1)

tactic: exact zero_le _
state_before: case inl
b n : ℕ
hb : b ≤ 1
⊢ 0 ≤ log b (n + 1)

tactic: exact le_log_of_pow_le hb (pow_log_le_add_one _ _)
state_before: case inr
b n : ℕ
hb : 1 < b
⊢ log b n ≤ log b (n + 1)
Theorem: Finsupp.finsuppProdLEquiv_apply
File: Mathlib/LinearAlgebra/Finsupp.lean

tactic: rw [finsuppProdLEquiv, LinearEquiv.coe_mk, finsuppProdEquiv, Finsupp.curry_apply]
state_before: α✝ : Type ?u.639667
M✝ : Type ?u.639670
N : Type ?u.639673
P : Type ?u.639676
R✝ : Type ?u.639679
S : Type ?u.639682
inst✝¹⁰ : Semiring R✝
inst✝⁹ : Semiring S
inst✝⁸ : AddCommMonoid M✝
inst✝⁷ : Module R✝ M✝
inst✝⁶ : AddCommMonoid N
inst✝⁵ : Module R✝ N
inst✝⁴ : AddCommMonoid P
inst✝³ : Module R✝ P
α : Type u_1
β : Type u_2
R : Type u_3
M : Type u_4
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
f : α × β →₀ M
x : α
y : β
⊢ ↑(↑(↑(finsuppProdLEquiv R) f) x) y = ↑f (x, y)
Theorem: Subgroup.exists_right_transversal
File: Mathlib/GroupTheory/Complement.lean

tactic: refine'
  ⟨Set.range (Function.update Quotient.out' _ g), range_mem_rightTransversals fun q => _,
    Quotient.mk'' g, Function.update_same (Quotient.mk'' g) g Quotient.out'⟩
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
g : G
⊢ ∃ S, S ∈ rightTransversals ↑H ∧ g ∈ S

tactic: by_cases hq : q = Quotient.mk'' g
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
g : G
q : Quotient (QuotientGroup.rightRel H)
⊢ Quotient.mk'' (Function.update Quotient.out' (Quotient.mk'' g) g q) = q

tactic: exact hq.symm ▸ congr_arg _ (Function.update_same (Quotient.mk'' g) g Quotient.out')
state_before: case pos
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
g : G
q : Quotient (QuotientGroup.rightRel H)
hq : q = Quotient.mk'' g
⊢ Quotient.mk'' (Function.update Quotient.out' (Quotient.mk'' g) g q) = q

tactic: exact Eq.trans (congr_arg _ (Function.update_noteq hq g Quotient.out')) q.out_eq'
state_before: case neg
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
g : G
q : Quotient (QuotientGroup.rightRel H)
hq : ¬q = Quotient.mk'' g
⊢ Quotient.mk'' (Function.update Quotient.out' (Quotient.mk'' g) g q) = q
Theorem: expSeries_apply_zero
File: Mathlib/Analysis/NormedSpace/Exponential.lean

tactic: rw [expSeries_apply_eq]
state_before: 𝕂 : Type u_2
𝔸 : Type u_1
inst✝⁴ : Field 𝕂
inst✝³ : Ring 𝔸
inst✝² : Algebra 𝕂 𝔸
inst✝¹ : TopologicalSpace 𝔸
inst✝ : TopologicalRing 𝔸
n : ℕ
⊢ (↑(expSeries 𝕂 𝔸 n) fun x => 0) = Pi.single 0 1 n

tactic: cases' n with n
state_before: 𝕂 : Type u_2
𝔸 : Type u_1
inst✝⁴ : Field 𝕂
inst✝³ : Ring 𝔸
inst✝² : Algebra 𝕂 𝔸
inst✝¹ : TopologicalSpace 𝔸
inst✝ : TopologicalRing 𝔸
n : ℕ
⊢ (↑n !)⁻¹ • 0 ^ n = Pi.single 0 1 n

tactic: rw [pow_zero, Nat.factorial_zero, Nat.cast_one, inv_one, one_smul, Pi.single_eq_same]
state_before: case zero
𝕂 : Type u_2
𝔸 : Type u_1
inst✝⁴ : Field 𝕂
inst✝³ : Ring 𝔸
inst✝² : Algebra 𝕂 𝔸
inst✝¹ : TopologicalSpace 𝔸
inst✝ : TopologicalRing 𝔸
⊢ (↑Nat.zero !)⁻¹ • 0 ^ Nat.zero = Pi.single 0 1 Nat.zero

tactic: rw [zero_pow (Nat.succ_pos _), smul_zero, Pi.single_eq_of_ne n.succ_ne_zero]
state_before: case succ
𝕂 : Type u_2
𝔸 : Type u_1
inst✝⁴ : Field 𝕂
inst✝³ : Ring 𝔸
inst✝² : Algebra 𝕂 𝔸
inst✝¹ : TopologicalSpace 𝔸
inst✝ : TopologicalRing 𝔸
n : ℕ
⊢ (↑(Nat.succ n)!)⁻¹ • 0 ^ Nat.succ n = Pi.single 0 1 (Nat.succ n)
Theorem: Int.even_sub
File: Mathlib/Data/Int/Parity.lean

tactic: simp [sub_eq_add_neg, parity_simps]
state_before: m n : ℤ
⊢ Even (m - n) ↔ (Even m ↔ Even n)
Theorem: TopologicalSpace.eq_induced_by_maps_to_sierpinski
File: Mathlib/Topology/ContinuousFunction/T0Sierpinski.lean

tactic: apply le_antisymm
state_before: X : Type u_1
t : TopologicalSpace X
⊢ t = ⨅ (u : Opens X), induced (fun x => x ∈ u) sierpinskiSpace

tactic: rw [le_iInf_iff]
state_before: case a
X : Type u_1
t : TopologicalSpace X
⊢ t ≤ ⨅ (u : Opens X), induced (fun x => x ∈ u) sierpinskiSpace

tactic: exact fun u => Continuous.le_induced (isOpen_iff_continuous_mem.mp u.2)
state_before: case a
X : Type u_1
t : TopologicalSpace X
⊢ ∀ (i : Opens X), t ≤ induced (fun x => x ∈ i) sierpinskiSpace

tactic: intro u h
state_before: case a
X : Type u_1
t : TopologicalSpace X
⊢ (⨅ (u : Opens X), induced (fun x => x ∈ u) sierpinskiSpace) ≤ t

tactic: rw [← generateFrom_iUnion_isOpen]
state_before: case a
X : Type u_1
t : TopologicalSpace X
u : Set X
h : IsOpen u
⊢ IsOpen u

tactic: apply isOpen_generateFrom_of_mem
state_before: case a
X : Type u_1
t : TopologicalSpace X
u : Set X
h : IsOpen u
⊢ IsOpen u

tactic: simp only [Set.mem_iUnion, Set.mem_setOf_eq, isOpen_induced_iff]
state_before: case a.hs
X : Type u_1
t : TopologicalSpace X
u : Set X
h : IsOpen u
⊢ u ∈ ⋃ (i : Opens X), {s | IsOpen s}

tactic: exact ⟨⟨u, h⟩, {True}, isOpen_singleton_true, by simp [Set.preimage]⟩
state_before: case a.hs
X : Type u_1
t : TopologicalSpace X
u : Set X
h : IsOpen u
⊢ ∃ i t_1, IsOpen t_1 ∧ (fun x => x ∈ i) ⁻¹' t_1 = u

tactic: simp [Set.preimage]
state_before: X : Type u_1
t : TopologicalSpace X
u : Set X
h : IsOpen u
⊢ (fun x => x ∈ { carrier := u, is_open' := h }) ⁻¹' {True} = u
Theorem: Set.einfsep_triple
File: Mathlib/Topology/MetricSpace/Infsep.lean

tactic: simp_rw [einfsep_insert, iInf_insert, iInf_singleton, einfsep_singleton, inf_top_eq,
  ciInf_pos hxy, ciInf_pos hyz, ciInf_pos hxz]
state_before: α : Type u_1
β : Type ?u.46357
inst✝ : PseudoEMetricSpace α
x y z : α
s t : Set α
hxy : x ≠ y
hyz : y ≠ z
hxz : x ≠ z
⊢ einfsep {x, y, z} = edist x y ⊓ edist x z ⊓ edist y z
Theorem: Bool.and_le_right
File: Mathlib/Data/Bool/Basic.lean

tactic: decide
state_before: ⊢ ∀ (x y : Bool), (x && y) ≤ y
Theorem: EReal.exists_rat_btwn_of_lt
File: Mathlib/Data/Real/EReal.lean

tactic: simp [exists_rat_btwn (EReal.coe_lt_coe_iff.1 h)]
state_before: a b : ℝ
h : ↑a < ↑b
⊢ ∃ x, ↑a < ↑↑x ∧ ↑↑x < ↑b

tactic: simpa using hab
state_before: a : ℝ
x✝ : ↑a < ⊤
b : ℚ
hab : a < ↑b
⊢ ↑a < ↑↑b

tactic: simpa using hab
state_before: a : ℝ
x✝ : ⊥ < ↑a
b : ℚ
hab : ↑b < a
⊢ ↑↑b < ↑a
Theorem: SequentiallyComplete.le_nhds_of_seq_tendsto_nhds
File: Mathlib/Topology/UniformSpace/Cauchy.lean

tactic: rcases U_le s hs with ⟨m, hm⟩
state_before: α : Type u
β : Type v
inst✝ : UniformSpace α
f : Filter α
hf : Cauchy f
U : ℕ → Set (α × α)
U_mem : ∀ (n : ℕ), U n ∈ 𝓤 α
U_le : ∀ (s : Set (α × α)), s ∈ 𝓤 α → ∃ n, U n ⊆ s
a : α
ha : Tendsto (seq hf U_mem) atTop (𝓝 a)
s : Set (α × α)
hs : s ∈ 𝓤 α
⊢ ∃ t, t ∈ f ∧ t ×ˢ t ⊆ s ∧ ∃ y, (a, y) ∈ s ∧ y ∈ t

tactic: rcases tendsto_atTop'.1 ha _ (mem_nhds_left a (U_mem m)) with ⟨n, hn⟩
state_before: case intro
α : Type u
β : Type v
inst✝ : UniformSpace α
f : Filter α
hf : Cauchy f
U : ℕ → Set (α × α)
U_mem : ∀ (n : ℕ), U n ∈ 𝓤 α
U_le : ∀ (s : Set (α × α)), s ∈ 𝓤 α → ∃ n, U n ⊆ s
a : α
ha : Tendsto (seq hf U_mem) atTop (𝓝 a)
s : Set (α × α)
hs : s ∈ 𝓤 α
m : ℕ
hm : U m ⊆ s
⊢ ∃ t, t ∈ f ∧ t ×ˢ t ⊆ s ∧ ∃ y, (a, y) ∈ s ∧ y ∈ t

tactic: refine'
  ⟨setSeq hf U_mem (max m n), setSeq_mem hf U_mem _, _, seq hf U_mem (max m n), _,
    seq_mem hf U_mem _⟩
state_before: case intro.intro
α : Type u
β : Type v
inst✝ : UniformSpace α
f : Filter α
hf : Cauchy f
U : ℕ → Set (α × α)
U_mem : ∀ (n : ℕ), U n ∈ 𝓤 α
U_le : ∀ (s : Set (α × α)), s ∈ 𝓤 α → ∃ n, U n ⊆ s
a : α
ha : Tendsto (seq hf U_mem) atTop (𝓝 a)
s : Set (α × α)
hs : s ∈ 𝓤 α
m : ℕ
hm : U m ⊆ s
n : ℕ
hn : ∀ (b : ℕ), b ≥ n → seq hf U_mem b ∈ {y | (a, y) ∈ U m}
⊢ ∃ t, t ∈ f ∧ t ×ˢ t ⊆ s ∧ ∃ y, (a, y) ∈ s ∧ y ∈ t

tactic: have := le_max_left m n
state_before: case intro.intro.refine'_1
α : Type u
β : Type v
inst✝ : UniformSpace α
f : Filter α
hf : Cauchy f
U : ℕ → Set (α × α)
U_mem : ∀ (n : ℕ), U n ∈ 𝓤 α
U_le : ∀ (s : Set (α × α)), s ∈ 𝓤 α → ∃ n, U n ⊆ s
a : α
ha : Tendsto (seq hf U_mem) atTop (𝓝 a)
s : Set (α × α)
hs : s ∈ 𝓤 α
m : ℕ
hm : U m ⊆ s
n : ℕ
hn : ∀ (b : ℕ), b ≥ n → seq hf U_mem b ∈ {y | (a, y) ∈ U m}
⊢ setSeq hf U_mem (max m n) ×ˢ setSeq hf U_mem (max m n) ⊆ s

tactic: exact Set.Subset.trans (setSeq_prod_subset hf U_mem this this) hm
state_before: case intro.intro.refine'_1
α : Type u
β : Type v
inst✝ : UniformSpace α
f : Filter α
hf : Cauchy f
U : ℕ → Set (α × α)
U_mem : ∀ (n : ℕ), U n ∈ 𝓤 α
U_le : ∀ (s : Set (α × α)), s ∈ 𝓤 α → ∃ n, U n ⊆ s
a : α
ha : Tendsto (seq hf U_mem) atTop (𝓝 a)
s : Set (α × α)
hs : s ∈ 𝓤 α
m : ℕ
hm : U m ⊆ s
n : ℕ
hn : ∀ (b : ℕ), b ≥ n → seq hf U_mem b ∈ {y | (a, y) ∈ U m}
this : m ≤ max m n
⊢ setSeq hf U_mem (max m n) ×ˢ setSeq hf U_mem (max m n) ⊆ s

tactic: exact hm (hn _ <| le_max_right m n)
state_before: case intro.intro.refine'_2
α : Type u
β : Type v
inst✝ : UniformSpace α
f : Filter α
hf : Cauchy f
U : ℕ → Set (α × α)
U_mem : ∀ (n : ℕ), U n ∈ 𝓤 α
U_le : ∀ (s : Set (α × α)), s ∈ 𝓤 α → ∃ n, U n ⊆ s
a : α
ha : Tendsto (seq hf U_mem) atTop (𝓝 a)
s : Set (α × α)
hs : s ∈ 𝓤 α
m : ℕ
hm : U m ⊆ s
n : ℕ
hn : ∀ (b : ℕ), b ≥ n → seq hf U_mem b ∈ {y | (a, y) ∈ U m}
⊢ (a, seq hf U_mem (max m n)) ∈ s
Theorem: Nat.add_mod_of_add_mod_lt
File: Mathlib/Data/Nat/ModEq.lean

tactic: rw [← add_mod_add_ite, if_neg (not_le_of_lt hc), add_zero]
state_before: m n a✝ b✝ c✝ d a b c : ℕ
hc : a % c + b % c < c
⊢ (a + b) % c = a % c + b % c
Theorem: StarAlgEquiv.symm_symm
File: Mathlib/Algebra/Star/StarAlgHom.lean

tactic: ext
state_before: F : Type ?u.1020688
R : Type u_1
A : Type u_2
B : Type u_3
C : Type ?u.1020700
inst✝¹¹ : Add A
inst✝¹⁰ : Add B
inst✝⁹ : Mul A
inst✝⁸ : Mul B
inst✝⁷ : SMul R A
inst✝⁶ : SMul R B
inst✝⁵ : Star A
inst✝⁴ : Star B
inst✝³ : Add C
inst✝² : Mul C
inst✝¹ : SMul R C
inst✝ : Star C
e : A ≃⋆ₐ[R] B
⊢ symm (symm e) = e

tactic: rfl
state_before: case h
F : Type ?u.1020688
R : Type u_1
A : Type u_2
B : Type u_3
C : Type ?u.1020700
inst✝¹¹ : Add A
inst✝¹⁰ : Add B
inst✝⁹ : Mul A
inst✝⁸ : Mul B
inst✝⁷ : SMul R A
inst✝⁶ : SMul R B
inst✝⁵ : Star A
inst✝⁴ : Star B
inst✝³ : Add C
inst✝² : Mul C
inst✝¹ : SMul R C
inst✝ : Star C
e : A ≃⋆ₐ[R] B
a✝ : A
⊢ ↑(symm (symm e)) a✝ = ↑e a✝
Theorem: Urysohns.CU.lim_eq_midpoint
File: Mathlib/Topology/UrysohnsLemma.lean

tactic: refine' tendsto_nhds_unique (c.tendsto_approx_atTop x) ((tendsto_add_atTop_iff_nat 1).1 _)
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
c : CU X
x : X
⊢ CU.lim c x = midpoint ℝ (CU.lim (left c) x) (CU.lim (right c) x)

tactic: simp only [approx]
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
c : CU X
x : X
⊢ Tendsto (fun n => approx (n + 1) c x) atTop (𝓝 (midpoint ℝ (CU.lim (left c) x) (CU.lim (right c) x)))

tactic: exact (c.left.tendsto_approx_atTop x).midpoint (c.right.tendsto_approx_atTop x)
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
c : CU X
x : X
⊢ Tendsto (fun n => midpoint ℝ (approx (Nat.add n 0) (left c) x) (approx (Nat.add n 0) (right c) x)) atTop
    (𝓝 (midpoint ℝ (CU.lim (left c) x) (CU.lim (right c) x)))
Theorem: LinearMap.lTensor_sub
File: Mathlib/LinearAlgebra/TensorProduct.lean

tactic: simp_rw [← coe_lTensorHom]
state_before: R : Type u_1
inst✝¹⁰ : CommSemiring R
M : Type u_4
N : Type u_2
P : Type u_3
Q : Type ?u.1448279
S : Type ?u.1448282
inst✝⁹ : AddCommGroup M
inst✝⁸ : AddCommGroup N
inst✝⁷ : AddCommGroup P
inst✝⁶ : AddCommGroup Q
inst✝⁵ : AddCommGroup S
inst✝⁴ : Module R M
inst✝³ : Module R N
inst✝² : Module R P
inst✝¹ : Module R Q
inst✝ : Module R S
f g : N →ₗ[R] P
⊢ lTensor M (f - g) = lTensor M f - lTensor M g

tactic: exact (lTensorHom (R:=R) (N:=N) (P:=P) M).map_sub f g
state_before: R : Type u_1
inst✝¹⁰ : CommSemiring R
M : Type u_4
N : Type u_2
P : Type u_3
Q : Type ?u.1448279
S : Type ?u.1448282
inst✝⁹ : AddCommGroup M
inst✝⁸ : AddCommGroup N
inst✝⁷ : AddCommGroup P
inst✝⁶ : AddCommGroup Q
inst✝⁵ : AddCommGroup S
inst✝⁴ : Module R M
inst✝³ : Module R N
inst✝² : Module R P
inst✝¹ : Module R Q
inst✝ : Module R S
f g : N →ₗ[R] P
⊢ ↑(lTensorHom M) (f - g) = ↑(lTensorHom M) f - ↑(lTensorHom M) g
Theorem: CategoryTheory.MonoidalCategory.pentagon_inv_hom
File: Mathlib/CategoryTheory/Monoidal/CoherenceLemmas.lean

tactic: coherence
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : MonoidalCategory C
W X Y Z : C
⊢ (α_ (W ⊗ X) Y Z).inv ≫ ((α_ W X Y).hom ⊗ 𝟙 Z) = (α_ W X (Y ⊗ Z)).hom ≫ (𝟙 W ⊗ (α_ X Y Z).inv) ≫ (α_ W (X ⊗ Y) Z).inv
Theorem: Asymptotics.IsLittleO.add_add
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: refine' (h₁.trans_le fun x => _).add (h₂.trans_le _) <;> simp [abs_of_nonneg, add_nonneg]
state_before: α : Type u_1
β : Type ?u.208941
E : Type ?u.208944
F : Type ?u.208947
G : Type ?u.208950
E' : Type u_2
F' : Type u_3
G' : Type ?u.208959
E'' : Type ?u.208962
F'' : Type ?u.208965
G'' : Type ?u.208968
R : Type ?u.208971
R' : Type ?u.208974
𝕜 : Type ?u.208977
𝕜' : Type ?u.208980
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
f₁ f₂ : α → E'
g₁ g₂ : α → F'
h₁ : f₁ =o[l] g₁
h₂ : f₂ =o[l] g₂
⊢ (fun x => f₁ x + f₂ x) =o[l] fun x => ‖g₁ x‖ + ‖g₂ x‖
Theorem: Ideal.Quotient.index_eq_zero
File: Mathlib/Algebra/CharP/Quotient.lean

tactic: rw [AddSubgroup.index, Nat.card_eq]
state_before: R : Type u_1
inst✝ : CommRing R
I : Ideal R
⊢ ↑(AddSubgroup.index (Submodule.toAddSubgroup I)) = 0

tactic: split_ifs with hq
state_before: R : Type u_1
inst✝ : CommRing R
I : Ideal R
⊢ ↑(if h : Finite (R ⧸ Submodule.toAddSubgroup I) then Fintype.card (R ⧸ Submodule.toAddSubgroup I) else 0) = 0

tactic: swap
state_before: case inl
R : Type u_1
inst✝ : CommRing R
I : Ideal R
hq : Finite (R ⧸ Submodule.toAddSubgroup I)
⊢ ↑(Fintype.card (R ⧸ Submodule.toAddSubgroup I)) = 0

case inr
R : Type u_1
inst✝ : CommRing R
I : Ideal R
hq : ¬Finite (R ⧸ Submodule.toAddSubgroup I)
⊢ ↑0 = 0

tactic: simp
state_before: case inr
R : Type u_1
inst✝ : CommRing R
I : Ideal R
hq : ¬Finite (R ⧸ Submodule.toAddSubgroup I)
⊢ ↑0 = 0

case inl
R : Type u_1
inst✝ : CommRing R
I : Ideal R
hq : Finite (R ⧸ Submodule.toAddSubgroup I)
⊢ ↑(Fintype.card (R ⧸ Submodule.toAddSubgroup I)) = 0

tactic: by_contra h
state_before: case inl
R : Type u_1
inst✝ : CommRing R
I : Ideal R
hq : Finite (R ⧸ Submodule.toAddSubgroup I)
⊢ ↑(Fintype.card (R ⧸ Submodule.toAddSubgroup I)) = 0

tactic: letI : Fintype (R ⧸ I) := @Fintype.ofFinite _ hq
state_before: case inl
R : Type u_1
inst✝ : CommRing R
I : Ideal R
hq : Finite (R ⧸ Submodule.toAddSubgroup I)
h : ¬↑(Fintype.card (R ⧸ Submodule.toAddSubgroup I)) = 0
⊢ False

tactic: have h : (Fintype.card (R ⧸ I) : R ⧸ I) ≠ 0 := h
state_before: case inl
R : Type u_1
inst✝ : CommRing R
I : Ideal R
hq : Finite (R ⧸ Submodule.toAddSubgroup I)
h : ¬↑(Fintype.card (R ⧸ Submodule.toAddSubgroup I)) = 0
this : Fintype (R ⧸ I) := Fintype.ofFinite (R ⧸ I)
⊢ False

tactic: simp at h
state_before: case inl
R : Type u_1
inst✝ : CommRing R
I : Ideal R
hq : Finite (R ⧸ Submodule.toAddSubgroup I)
h✝ : ¬↑(Fintype.card (R ⧸ Submodule.toAddSubgroup I)) = 0
this : Fintype (R ⧸ I) := Fintype.ofFinite (R ⧸ I)
h : ↑(Fintype.card (R ⧸ I)) ≠ 0
⊢ False
Theorem: MeasureTheory.absolutelyContinuous_map_div_left
File: Mathlib/MeasureTheory/Group/Prod.lean

tactic: simp_rw [div_eq_mul_inv]
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulLeftInvariant μ
g : G
⊢ μ ≪ map (fun h => g / h) μ

tactic: erw [← map_map (measurable_const_mul g) measurable_inv]
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulLeftInvariant μ
g : G
⊢ μ ≪ map (fun h => g * h⁻¹) μ

tactic: conv_lhs => rw [← map_mul_left_eq_self μ g]
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulLeftInvariant μ
g : G
⊢ μ ≪ map (fun x => g * x) (map Inv.inv μ)

tactic: exact (absolutelyContinuous_inv μ).map (measurable_const_mul g)
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulLeftInvariant μ
g : G
⊢ map (fun x => g * x) μ ≪ map (fun x => g * x) (map Inv.inv μ)
Theorem: Finset.nnnorm_prod_le
File: Mathlib/Analysis/Normed/Field/Basic.lean

tactic: simp [NNReal.coe_prod]
state_before: α✝ : Type ?u.124202
β : Type ?u.124205
γ : Type ?u.124208
ι : Type u_2
inst✝² : SeminormedRing α✝
α : Type u_1
inst✝¹ : NormedCommRing α
inst✝ : NormOneClass α
s : Finset ι
f : ι → α
⊢ ∏ i in s, ‖f i‖ = (fun a => ↑a) (∏ i in s, ‖f i‖₊)
Theorem: Multiset.prod_map_zpow
File: Mathlib/Algebra/BigOperators/Multiset/Basic.lean

tactic: convert (m.map f).prod_hom (zpowGroupHom n : α →* α)
state_before: ι : Type u_2
α : Type u_1
β : Type ?u.99606
γ : Type ?u.99609
inst✝ : DivisionCommMonoid α
m : Multiset ι
f g : ι → α
n : ℤ
⊢ prod (map (fun i => f i ^ n) m) = prod (map f m) ^ n

tactic: simp only [map_map, Function.comp_apply, zpowGroupHom_apply]
state_before: case h.e'_2.h.e'_3
ι : Type u_2
α : Type u_1
β : Type ?u.99606
γ : Type ?u.99609
inst✝ : DivisionCommMonoid α
m : Multiset ι
f g : ι → α
n : ℤ
⊢ map (fun i => f i ^ n) m = map (↑(zpowGroupHom n)) (map f m)