tasksource/leandojo huggingface dataset:
Theorem: Cardinal.aleph0_le_mul_iff
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: let h := (@mul_lt_aleph0_iff a b).not
state_before: α β : Type u
a b : Cardinal
⊢ ℵ₀ ≤ a * b ↔ a ≠ 0 ∧ b ≠ 0 ∧ (ℵ₀ ≤ a ∨ ℵ₀ ≤ b)

tactic: rwa [not_lt, not_or, not_or, not_and_or, not_lt, not_lt] at h
state_before: α β : Type u
a b : Cardinal
h : ¬a * b < ℵ₀ ↔ ¬(a = 0 ∨ b = 0 ∨ a < ℵ₀ ∧ b < ℵ₀) := Iff.not mul_lt_aleph0_iff
⊢ ℵ₀ ≤ a * b ↔ a ≠ 0 ∧ b ≠ 0 ∧ (ℵ₀ ≤ a ∨ ℵ₀ ≤ b)
Theorem: Set.preimage_image_sigmaMk_of_ne
File: Mathlib/Data/Set/Sigma.lean

tactic: ext x
state_before: ι : Type u_1
ι' : Type ?u.678
α : ι → Type u_2
β : ι → Type ?u.688
s✝ s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x : (i : ι) × α i
i j : ι
a : α i
h : i ≠ j
s : Set (α j)
⊢ Sigma.mk i ⁻¹' (Sigma.mk j '' s) = ∅

tactic: simp [h.symm]
state_before: case h
ι : Type u_1
ι' : Type ?u.678
α : ι → Type u_2
β : ι → Type ?u.688
s✝ s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x✝ : (i : ι) × α i
i j : ι
a : α i
h : i ≠ j
s : Set (α j)
x : α i
⊢ x ∈ Sigma.mk i ⁻¹' (Sigma.mk j '' s) ↔ x ∈ ∅
Theorem: Finsupp.update_eq_erase_add_single
File: Mathlib/Data/Finsupp/Defs.lean

tactic: ext j
state_before: α : Type u_1
β : Type ?u.300562
γ : Type ?u.300565
ι : Type ?u.300568
M : Type u_2
M' : Type ?u.300574
N : Type ?u.300577
P : Type ?u.300580
G : Type ?u.300583
H : Type ?u.300586
R : Type ?u.300589
S : Type ?u.300592
inst✝ : AddZeroClass M
f : α →₀ M
a : α
b : M
⊢ update f a b = erase a f + single a b

tactic: rcases eq_or_ne a j with (rfl | h)
state_before: case h
α : Type u_1
β : Type ?u.300562
γ : Type ?u.300565
ι : Type ?u.300568
M : Type u_2
M' : Type ?u.300574
N : Type ?u.300577
P : Type ?u.300580
G : Type ?u.300583
H : Type ?u.300586
R : Type ?u.300589
S : Type ?u.300592
inst✝ : AddZeroClass M
f : α →₀ M
a : α
b : M
j : α
⊢ ↑(update f a b) j = ↑(erase a f + single a b) j

tactic: simp
state_before: case h.inl
α : Type u_1
β : Type ?u.300562
γ : Type ?u.300565
ι : Type ?u.300568
M : Type u_2
M' : Type ?u.300574
N : Type ?u.300577
P : Type ?u.300580
G : Type ?u.300583
H : Type ?u.300586
R : Type ?u.300589
S : Type ?u.300592
inst✝ : AddZeroClass M
f : α →₀ M
a : α
b : M
⊢ ↑(update f a b) a = ↑(erase a f + single a b) a

tactic: simp [Function.update_noteq h.symm, single_apply, h, erase_ne, h.symm]
state_before: case h.inr
α : Type u_1
β : Type ?u.300562
γ : Type ?u.300565
ι : Type ?u.300568
M : Type u_2
M' : Type ?u.300574
N : Type ?u.300577
P : Type ?u.300580
G : Type ?u.300583
H : Type ?u.300586
R : Type ?u.300589
S : Type ?u.300592
inst✝ : AddZeroClass M
f : α →₀ M
a : α
b : M
j : α
h : a ≠ j
⊢ ↑(update f a b) j = ↑(erase a f + single a b) j
Theorem: Complex.cpow_neg_one
File: Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean

tactic: simpa using cpow_neg x 1
state_before: x : ℂ
⊢ x ^ (-1) = x⁻¹
Theorem: minpoly.dvd
File: Mathlib/FieldTheory/Minpoly/Field.lean

tactic: by_cases hp0 : p = 0
state_before: A : Type u_1
B : Type u_2
inst✝² : Field A
inst✝¹ : Ring B
inst✝ : Algebra A B
x : B
p : A[X]
hp : ↑(Polynomial.aeval x) p = 0
⊢ minpoly A x ∣ p

tactic: have hx : IsIntegral A x := by
  rw [← isAlgebraic_iff_isIntegral]
  exact ⟨p, hp0, hp⟩
state_before: case neg
A : Type u_1
B : Type u_2
inst✝² : Field A
inst✝¹ : Ring B
inst✝ : Algebra A B
x : B
p : A[X]
hp : ↑(Polynomial.aeval x) p = 0
hp0 : ¬p = 0
⊢ minpoly A x ∣ p

tactic: rw [← dvd_iff_modByMonic_eq_zero (monic hx)]
state_before: case neg
A : Type u_1
B : Type u_2
inst✝² : Field A
inst✝¹ : Ring B
inst✝ : Algebra A B
x : B
p : A[X]
hp : ↑(Polynomial.aeval x) p = 0
hp0 : ¬p = 0
hx : IsIntegral A x
⊢ minpoly A x ∣ p

tactic: by_contra hnz
state_before: case neg
A : Type u_1
B : Type u_2
inst✝² : Field A
inst✝¹ : Ring B
inst✝ : Algebra A B
x : B
p : A[X]
hp : ↑(Polynomial.aeval x) p = 0
hp0 : ¬p = 0
hx : IsIntegral A x
⊢ p %ₘ minpoly A x = 0

tactic: have hd := degree_le_of_ne_zero A x hnz
  ((aeval_modByMonic_eq_self_of_root (monic hx) (aeval _ _)).trans hp)
state_before: case neg
A : Type u_1
B : Type u_2
inst✝² : Field A
inst✝¹ : Ring B
inst✝ : Algebra A B
x : B
p : A[X]
hp : ↑(Polynomial.aeval x) p = 0
hp0 : ¬p = 0
hx : IsIntegral A x
hnz : ¬p %ₘ minpoly A x = 0
⊢ False

tactic: contrapose! hd
state_before: case neg
A : Type u_1
B : Type u_2
inst✝² : Field A
inst✝¹ : Ring B
inst✝ : Algebra A B
x : B
p : A[X]
hp : ↑(Polynomial.aeval x) p = 0
hp0 : ¬p = 0
hx : IsIntegral A x
hnz : ¬p %ₘ minpoly A x = 0
hd : degree (minpoly A x) ≤ degree (p %ₘ minpoly A x)
⊢ False

tactic: exact degree_modByMonic_lt _ (monic hx)
state_before: case neg
A : Type u_1
B : Type u_2
inst✝² : Field A
inst✝¹ : Ring B
inst✝ : Algebra A B
x : B
p : A[X]
hp : ↑(Polynomial.aeval x) p = 0
hp0 : ¬p = 0
hx : IsIntegral A x
hnz : ¬p %ₘ minpoly A x = 0
hd : ¬False
⊢ degree (p %ₘ minpoly A x) < degree (minpoly A x)

tactic: simp only [hp0, dvd_zero]
state_before: case pos
A : Type u_1
B : Type u_2
inst✝² : Field A
inst✝¹ : Ring B
inst✝ : Algebra A B
x : B
p : A[X]
hp : ↑(Polynomial.aeval x) p = 0
hp0 : p = 0
⊢ minpoly A x ∣ p

tactic: rw [← isAlgebraic_iff_isIntegral]
state_before: A : Type u_1
B : Type u_2
inst✝² : Field A
inst✝¹ : Ring B
inst✝ : Algebra A B
x : B
p : A[X]
hp : ↑(Polynomial.aeval x) p = 0
hp0 : ¬p = 0
⊢ IsIntegral A x

tactic: exact ⟨p, hp0, hp⟩
state_before: A : Type u_1
B : Type u_2
inst✝² : Field A
inst✝¹ : Ring B
inst✝ : Algebra A B
x : B
p : A[X]
hp : ↑(Polynomial.aeval x) p = 0
hp0 : ¬p = 0
⊢ IsAlgebraic A x
Theorem: Stream'.drop_drop
File: Mathlib/Data/Stream/Init.lean

tactic: ext
state_before: α : Type u
β : Type v
δ : Type w
n m : ℕ
s : Stream' α
⊢ drop n (drop m s) = drop (n + m) s

tactic: simp [Nat.add_assoc]
state_before: case a
α : Type u
β : Type v
δ : Type w
n m : ℕ
s : Stream' α
n✝ : ℕ
⊢ nth (drop n (drop m s)) n✝ = nth (drop (n + m) s) n✝
Theorem: ConvexCone.pointed_zero
File: Mathlib/Analysis/Convex/Cone/Basic.lean

tactic: rw [Pointed, mem_zero]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.98911
G : Type ?u.98914
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : Module 𝕜 E
⊢ Pointed 0
Theorem: Finpartition.exists_le_of_le
File: Mathlib/Order/Partition/Finpartition.lean

tactic: by_contra H
state_before: α : Type u_1
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
a b : α
P Q : Finpartition a
h : P ≤ Q
hb : b ∈ Q.parts
⊢ ∃ c, c ∈ P.parts ∧ c ≤ b

tactic: refine' Q.ne_bot hb (disjoint_self.1 <| Disjoint.mono_right (Q.le hb) _)
state_before: α : Type u_1
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
a b : α
P Q : Finpartition a
h : P ≤ Q
hb : b ∈ Q.parts
H : ¬∃ c, c ∈ P.parts ∧ c ≤ b
⊢ False

tactic: rw [← P.supParts, Finset.disjoint_sup_right]
state_before: α : Type u_1
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
a b : α
P Q : Finpartition a
h : P ≤ Q
hb : b ∈ Q.parts
H : ¬∃ c, c ∈ P.parts ∧ c ≤ b
⊢ Disjoint b a

tactic: rintro c hc
state_before: α : Type u_1
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
a b : α
P Q : Finpartition a
h : P ≤ Q
hb : b ∈ Q.parts
H : ¬∃ c, c ∈ P.parts ∧ c ≤ b
⊢ ∀ ⦃i : α⦄, i ∈ P.parts → Disjoint b (id i)

tactic: obtain ⟨d, hd, hcd⟩ := h hc
state_before: α : Type u_1
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
a b : α
P Q : Finpartition a
h : P ≤ Q
hb : b ∈ Q.parts
H : ¬∃ c, c ∈ P.parts ∧ c ≤ b
c : α
hc : c ∈ P.parts
⊢ Disjoint b (id c)

tactic: refine' (Q.disjoint hb hd _).mono_right hcd
state_before: case intro.intro
α : Type u_1
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
a b : α
P Q : Finpartition a
h : P ≤ Q
hb : b ∈ Q.parts
H : ¬∃ c, c ∈ P.parts ∧ c ≤ b
c : α
hc : c ∈ P.parts
d : α
hd : d ∈ Q.parts
hcd : c ≤ d
⊢ Disjoint b (id c)

tactic: rintro rfl
state_before: case intro.intro
α : Type u_1
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
a b : α
P Q : Finpartition a
h : P ≤ Q
hb : b ∈ Q.parts
H : ¬∃ c, c ∈ P.parts ∧ c ≤ b
c : α
hc : c ∈ P.parts
d : α
hd : d ∈ Q.parts
hcd : c ≤ d
⊢ b ≠ d

tactic: simp only [not_exists, not_and] at H
state_before: case intro.intro
α : Type u_1
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
a b : α
P Q : Finpartition a
h : P ≤ Q
hb : b ∈ Q.parts
H : ¬∃ c, c ∈ P.parts ∧ c ≤ b
c : α
hc : c ∈ P.parts
hd : b ∈ Q.parts
hcd : c ≤ b
⊢ False

tactic: exact H _ hc hcd
state_before: case intro.intro
α : Type u_1
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
a b : α
P Q : Finpartition a
h : P ≤ Q
hb : b ∈ Q.parts
c : α
hc : c ∈ P.parts
hd : b ∈ Q.parts
hcd : c ≤ b
H : ∀ (x : α), x ∈ P.parts → ¬x ≤ b
⊢ False
Theorem: Finset.toDual_min'
File: Mathlib/Data/Finset/Lattice.lean

tactic: rw [← WithBot.coe_eq_coe]
state_before: F : Type ?u.354773
α : Type u_1
β : Type ?u.354779
γ : Type ?u.354782
ι : Type ?u.354785
κ : Type ?u.354788
inst✝ : LinearOrder α
s✝ : Finset α
H : Finset.Nonempty s✝
x : α
s : Finset α
hs : Finset.Nonempty s
⊢ ↑toDual (min' s hs) = max' (image (↑toDual) s) (_ : Finset.Nonempty (image (↑toDual) s))

tactic: simp only [min'_eq_inf', id_eq, toDual_inf', Function.comp_apply, coe_sup', max'_eq_sup',
  sup_image]
state_before: F : Type ?u.354773
α : Type u_1
β : Type ?u.354779
γ : Type ?u.354782
ι : Type ?u.354785
κ : Type ?u.354788
inst✝ : LinearOrder α
s✝ : Finset α
H : Finset.Nonempty s✝
x : α
s : Finset α
hs : Finset.Nonempty s
⊢ ↑(↑toDual (min' s hs)) = ↑(max' (image (↑toDual) s) (_ : Finset.Nonempty (image (↑toDual) s)))

tactic: rfl
state_before: F : Type ?u.354773
α : Type u_1
β : Type ?u.354779
γ : Type ?u.354782
ι : Type ?u.354785
κ : Type ?u.354788
inst✝ : LinearOrder α
s✝ : Finset α
H : Finset.Nonempty s✝
x : α
s : Finset α
hs : Finset.Nonempty s
⊢ sup s (WithBot.some ∘ fun x => ↑toDual x) = sup s ((WithBot.some ∘ fun x => x) ∘ ↑toDual)
Theorem: ENNReal.ofReal_le_iff_le_toReal
File: Mathlib/Data/Real/ENNReal.lean

tactic: lift b to ℝ≥0 using hb
state_before: α : Type ?u.809256
β : Type ?u.809259
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ
b : ℝ≥0∞
hb : b ≠ ⊤
⊢ ENNReal.ofReal a ≤ b ↔ a ≤ ENNReal.toReal b

tactic: simpa [ENNReal.ofReal, ENNReal.toReal] using Real.toNNReal_le_iff_le_coe
state_before: case intro
α : Type ?u.809256
β : Type ?u.809259
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ
b : ℝ≥0
⊢ ENNReal.ofReal a ≤ ↑b ↔ a ≤ ENNReal.toReal ↑b
Theorem: AffineMap.apply_lineMap
File: Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean

tactic: simp [(lineMap_apply), (map_vadd), (linearMap_vsub)]
state_before: k : Type u_1
V1 : Type u_2
P1 : Type u_3
V2 : Type u_4
P2 : Type u_5
V3 : Type ?u.494433
P3 : Type ?u.494436
V4 : Type ?u.494439
P4 : Type ?u.494442
inst✝¹² : Ring k
inst✝¹¹ : AddCommGroup V1
inst✝¹⁰ : Module k V1
inst✝⁹ : AffineSpace V1 P1
inst✝⁸ : AddCommGroup V2
inst✝⁷ : Module k V2
inst✝⁶ : AffineSpace V2 P2
inst✝⁵ : AddCommGroup V3
inst✝⁴ : Module k V3
inst✝³ : AffineSpace V3 P3
inst✝² : AddCommGroup V4
inst✝¹ : Module k V4
inst✝ : AffineSpace V4 P4
f : P1 →ᵃ[k] P2
p₀ p₁ : P1
c : k
⊢ ↑f (↑(lineMap p₀ p₁) c) = ↑(lineMap (↑f p₀) (↑f p₁)) c
Theorem: MeasurableSpace.DynkinSystem.has_compl_iff
File: Mathlib/MeasureTheory/PiSystem.lean

tactic: simpa using d.has_compl h
state_before: α : Type u_1
d : DynkinSystem α
a : Set α
h : Has d (aᶜ)
⊢ Has d a
Theorem: FormalMultilinearSeries.order_eq_zero_iff
File: Mathlib/Analysis/Calculus/FormalMultilinearSeries.lean

tactic: simp [order_eq_zero_iff', hp]
state_before: 𝕜 : Type u
𝕜' : Type u'
E : Type v
F : Type w
G : Type x
inst✝¹⁰ : CommRing 𝕜
n : ℕ
inst✝⁹ : AddCommGroup E
inst✝⁸ : Module 𝕜 E
inst✝⁷ : TopologicalSpace E
inst✝⁶ : TopologicalAddGroup E
inst✝⁵ : ContinuousConstSMul 𝕜 E
inst✝⁴ : AddCommGroup F
inst✝³ : Module 𝕜 F
inst✝² : TopologicalSpace F
inst✝¹ : TopologicalAddGroup F
inst✝ : ContinuousConstSMul 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
hp : p ≠ 0
⊢ order p = 0 ↔ p 0 ≠ 0
Theorem: ZMod.pow_totient
File: Mathlib/FieldTheory/Finite/Basic.lean

tactic: cases n
state_before: K : Type ?u.893582
R : Type ?u.893585
n : ℕ
x : (ZMod n)ˣ
⊢ x ^ φ n = 1

tactic: rw [Nat.totient_zero, pow_zero]
state_before: case zero
K : Type ?u.893582
R : Type ?u.893585
x : (ZMod Nat.zero)ˣ
⊢ x ^ φ Nat.zero = 1

tactic: rw [← card_units_eq_totient, pow_card_eq_one]
state_before: case succ
K : Type ?u.893582
R : Type ?u.893585
n✝ : ℕ
x : (ZMod (Nat.succ n✝))ˣ
⊢ x ^ φ (Nat.succ n✝) = 1
Theorem: Set.preimage_neg_Ioo
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp [← Ioi_inter_Iio, inter_comm]
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ -Ioo a b = Ioo (-b) (-a)
Theorem: LieSubmodule.toEndomorphism_restrict_eq_toEndomorphism
File: Mathlib/Algebra/Lie/OfAssociative.lean

tactic: ext
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N : LieSubmodule R L M
x : L
h :
  optParam
    (∀ (m : M) (hm : m ∈ ↑N),
      ↑(LinearMap.comp (↑(toEndomorphism R L M) x) (Submodule.subtype ↑N)) { val := m, property := hm } ∈ ↑N)
    (_ :
      ∀ (m : M) (hm : m ∈ ↑N),
        ↑(LinearMap.comp (↑(toEndomorphism R L M) x) (Submodule.subtype ↑N)) { val := m, property := hm } ∈ ↑N)
⊢ LinearMap.restrict (↑(toEndomorphism R L M) x) h = ↑(toEndomorphism R L { x // x ∈ ↑N }) x

tactic: simp [LinearMap.restrict_apply]
state_before: case h.a
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N : LieSubmodule R L M
x : L
h :
  optParam
    (∀ (m : M) (hm : m ∈ ↑N),
      ↑(LinearMap.comp (↑(toEndomorphism R L M) x) (Submodule.subtype ↑N)) { val := m, property := hm } ∈ ↑N)
    (_ :
      ∀ (m : M) (hm : m ∈ ↑N),
        ↑(LinearMap.comp (↑(toEndomorphism R L M) x) (Submodule.subtype ↑N)) { val := m, property := hm } ∈ ↑N)
x✝ : { x // x ∈ ↑N }
⊢ ↑(↑(LinearMap.restrict (↑(toEndomorphism R L M) x) h) x✝) = ↑(↑(↑(toEndomorphism R L { x // x ∈ ↑N }) x) x✝)
Theorem: Ordinal.fp_bfamily_unbounded
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

tactic: rw [Set.mem_iInter₂]
state_before: o : Ordinal
f : (b : Ordinal) → b < o → Ordinal → Ordinal
H : ∀ (i : Ordinal) (hi : i < o), IsNormal (f i hi)
a : Ordinal
⊢ nfpBFamily o f a ∈ ⋂ (i : Ordinal) (hi : i < o), fixedPoints (f i hi)

tactic: exact fun i hi => nfpBFamily_fp (H i hi) _
state_before: o : Ordinal
f : (b : Ordinal) → b < o → Ordinal → Ordinal
H : ∀ (i : Ordinal) (hi : i < o), IsNormal (f i hi)
a : Ordinal
⊢ ∀ (i : Ordinal) (j : i < o), nfpBFamily o f a ∈ fixedPoints (f i j)
Theorem: Filter.Tendsto.atBot_zsmul_neg_const
File: Mathlib/Order/Filter/Archimedean.lean

tactic: simpa using hf.atBot_zsmul_const (neg_pos.2 hr)
state_before: α : Type u_2
R : Type u_1
l : Filter α
f✝ : α → R
r : R
inst✝¹ : LinearOrderedAddCommGroup R
inst✝ : Archimedean R
f : α → ℤ
hr : r < 0
hf : Tendsto f l atBot
⊢ Tendsto (fun x => f x • r) l atTop
Theorem: StarSubalgebra.eq_top_iff
File: Mathlib/Algebra/Star/Subalgebra.lean

tactic: rw [h]
state_before: F : Type ?u.755056
R : Type u_1
A : Type u_2
B : Type ?u.755065
inst✝⁹ : CommSemiring R
inst✝⁸ : StarRing R
inst✝⁷ : Semiring A
inst✝⁶ : Algebra R A
inst✝⁵ : StarRing A
inst✝⁴ : StarModule R A
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : StarRing B
inst✝ : StarModule R B
S : StarSubalgebra R A
h : S = ⊤
x : A
⊢ x ∈ S

tactic: exact mem_top
state_before: F : Type ?u.755056
R : Type u_1
A : Type u_2
B : Type ?u.755065
inst✝⁹ : CommSemiring R
inst✝⁸ : StarRing R
inst✝⁷ : Semiring A
inst✝⁶ : Algebra R A
inst✝⁵ : StarRing A
inst✝⁴ : StarModule R A
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : StarRing B
inst✝ : StarModule R B
S : StarSubalgebra R A
h : S = ⊤
x : A
⊢ x ∈ ⊤

tactic: ext x
state_before: F : Type ?u.755056
R : Type u_1
A : Type u_2
B : Type ?u.755065
inst✝⁹ : CommSemiring R
inst✝⁸ : StarRing R
inst✝⁷ : Semiring A
inst✝⁶ : Algebra R A
inst✝⁵ : StarRing A
inst✝⁴ : StarModule R A
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : StarRing B
inst✝ : StarModule R B
S : StarSubalgebra R A
h : ∀ (x : A), x ∈ S
⊢ S = ⊤

tactic: exact ⟨fun _ => mem_top, fun _ => h x⟩
state_before: case h
F : Type ?u.755056
R : Type u_1
A : Type u_2
B : Type ?u.755065
inst✝⁹ : CommSemiring R
inst✝⁸ : StarRing R
inst✝⁷ : Semiring A
inst✝⁶ : Algebra R A
inst✝⁵ : StarRing A
inst✝⁴ : StarModule R A
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : StarRing B
inst✝ : StarModule R B
S : StarSubalgebra R A
h : ∀ (x : A), x ∈ S
x : A
⊢ x ∈ S ↔ x ∈ ⊤
Theorem: Mathlib.Tactic.Abel.term_atomg
File: Mathlib/Tactic/Abel.lean

tactic: simp [termg]
state_before: α : Type u_1
inst✝ : AddCommGroup α
x : α
⊢ x = termg 1 x 0
Theorem: tendsto_fract_left'
File: Mathlib/Topology/Algebra/Order/Floor.lean

tactic: rw [← sub_sub_cancel (n : α) 1]
state_before: α : Type u_1
β : Type ?u.22476
γ : Type ?u.22479
inst✝⁴ : LinearOrderedRing α
inst✝³ : FloorRing α
inst✝² : TopologicalSpace α
inst✝¹ : OrderClosedTopology α
inst✝ : TopologicalAddGroup α
n : ℤ
⊢ Tendsto fract (𝓝[Iio ↑n] ↑n) (𝓝 1)

tactic: refine (tendsto_id.mono_left nhdsWithin_le_nhds).sub ?_
state_before: α : Type u_1
β : Type ?u.22476
γ : Type ?u.22479
inst✝⁴ : LinearOrderedRing α
inst✝³ : FloorRing α
inst✝² : TopologicalSpace α
inst✝¹ : OrderClosedTopology α
inst✝ : TopologicalAddGroup α
n : ℤ
⊢ Tendsto fract (𝓝[Iio ↑n] ↑n) (𝓝 (↑n - (↑n - 1)))

tactic: exact tendsto_floor_left' n
state_before: α : Type u_1
β : Type ?u.22476
γ : Type ?u.22479
inst✝⁴ : LinearOrderedRing α
inst✝³ : FloorRing α
inst✝² : TopologicalSpace α
inst✝¹ : OrderClosedTopology α
inst✝ : TopologicalAddGroup α
n : ℤ
⊢ Tendsto (fun x => ↑⌊x⌋) (𝓝[Iio ↑n] ↑n) (𝓝 (↑n - 1))
Theorem: Nat.modEq_and_modEq_iff_modEq_mul
File: Mathlib/Data/Nat/ModEq.lean

tactic: rw [Nat.modEq_iff_dvd, Nat.modEq_iff_dvd, ← Int.dvd_natAbs, Int.coe_nat_dvd, ← Int.dvd_natAbs,
  Int.coe_nat_dvd] at h
state_before: m✝ n✝ a✝ b✝ c d a b m n : ℕ
hmn : coprime m n
h : a ≡ b [MOD m] ∧ a ≡ b [MOD n]
⊢ a ≡ b [MOD m * n]

tactic: rw [Nat.modEq_iff_dvd, ← Int.dvd_natAbs, Int.coe_nat_dvd]
state_before: m✝ n✝ a✝ b✝ c d a b m n : ℕ
hmn : coprime m n
h : m ∣ Int.natAbs (↑b - ↑a) ∧ n ∣ Int.natAbs (↑b - ↑a)
⊢ a ≡ b [MOD m * n]

tactic: exact hmn.mul_dvd_of_dvd_of_dvd h.1 h.2
state_before: m✝ n✝ a✝ b✝ c d a b m n : ℕ
hmn : coprime m n
h : m ∣ Int.natAbs (↑b - ↑a) ∧ n ∣ Int.natAbs (↑b - ↑a)
⊢ m * n ∣ Int.natAbs (↑b - ↑a)
Theorem: summable_iff_of_summable_sub
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

tactic: simpa only [neg_sub] using hfg.neg
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.406920
δ : Type ?u.406923
inst✝² : AddCommGroup α
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalAddGroup α
f g : β → α
a a₁ a₂ : α
hfg : Summable fun b => f b - g b
hf : Summable f
⊢ Summable fun b => g b - f b
Theorem: CategoryTheory.Limits.pullbackDiagonalMapIso_hom_fst
File: Mathlib/CategoryTheory/Limits/Shapes/Diagonal.lean

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

tactic: simp
state_before: C : Type u_2
inst✝² : Category C
X Y Z : C
inst✝¹ : HasPullbacks C
U V₁ V₂ : C
f : X ⟶ Y
i : U ⟶ Y
i₁ : V₁ ⟶ pullback f i
i₂ : V₂ ⟶ pullback f i
inst✝ : HasPullback i₁ i₂
⊢ (Iso.mk (lift (snd ≫ fst) (snd ≫ snd) (_ : (snd ≫ fst) ≫ i₁ = (snd ≫ snd) ≫ i₂))
          (lift (fst ≫ i₁ ≫ fst)
            (map i₁ i₂ (i₁ ≫ snd) (i₂ ≫ snd) (𝟙 V₁) (𝟙 V₂) snd (_ : i₁ ≫ snd = 𝟙 V₁ ≫ i₁ ≫ snd)
              (_ : i₂ ≫ snd = 𝟙 V₂ ≫ i₂ ≫ snd))
            (_ :
              (fst ≫ i₁ ≫ fst) ≫ diagonal f =
                map i₁ i₂ (i₁ ≫ snd) (i₂ ≫ snd) (𝟙 V₁) (𝟙 V₂) snd (_ : i₁ ≫ snd = 𝟙 V₁ ≫ i₁ ≫ snd)
                    (_ : i₂ ≫ snd = 𝟙 V₂ ≫ i₂ ≫ snd) ≫
                  map (i₁ ≫ snd) (i₂ ≫ snd) f f (i₁ ≫ fst) (i₂ ≫ fst) i (_ : (i₁ ≫ snd) ≫ i = (i₁ ≫ fst) ≫ f)
                    (_ : (i₂ ≫ snd) ≫ i = (i₂ ≫ fst) ≫ f)))).hom ≫
      fst =
    snd ≫ fst
Theorem: Ideal.mk_ker
File: Mathlib/RingTheory/Ideal/QuotientOperations.lean

tactic: ext
state_before: R : Type u
S : Type v
F : Type w
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
⊢ RingHom.ker (Quotient.mk I) = I

tactic: rw [RingHom.ker, mem_comap, @Submodule.mem_bot _ _ _ _ Semiring.toModule _,
  Quotient.eq_zero_iff_mem]
state_before: case h
R : Type u
S : Type v
F : Type w
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
x✝ : R
⊢ x✝ ∈ RingHom.ker (Quotient.mk I) ↔ x✝ ∈ I
Theorem: OrderHom.lfp_lfp
File: Mathlib/Order/FixedPoints.lean

tactic: let a := lfp (lfp.comp h)
state_before: α : Type u
β : Type v
γ : Type w
inst✝¹ : CompleteLattice α
inst✝ : CompleteLattice β
f : β →o α
g : α →o β
h : α →o α →o α
⊢ ↑lfp (comp lfp h) = ↑lfp (onDiag h)

tactic: refine' (lfp_le _ _).antisymm (lfp_le _ (Eq.le _))
state_before: α : Type u
β : Type v
γ : Type w
inst✝¹ : CompleteLattice α
inst✝ : CompleteLattice β
f : β →o α
g : α →o β
h : α →o α →o α
a : α := ↑lfp (comp lfp h)
⊢ ↑lfp (comp lfp h) = ↑lfp (onDiag h)

tactic: have ha : (lfp ∘ h) a = a := (lfp.comp h).map_lfp
state_before: case refine'_2
α : Type u
β : Type v
γ : Type w
inst✝¹ : CompleteLattice α
inst✝ : CompleteLattice β
f : β →o α
g : α →o β
h : α →o α →o α
a : α := ↑lfp (comp lfp h)
⊢ ↑(onDiag h) (↑lfp (comp lfp h)) = ↑lfp (comp lfp h)

tactic: calc
  h a a = h a (lfp (h a)) := congr_arg (h a) ha.symm
  _ = lfp (h a) := (h a).map_lfp
  _ = a := ha
state_before: case refine'_2
α : Type u
β : Type v
γ : Type w
inst✝¹ : CompleteLattice α
inst✝ : CompleteLattice β
f : β →o α
g : α →o β
h : α →o α →o α
a : α := ↑lfp (comp lfp h)
ha : (↑lfp ∘ ↑h) a = a
⊢ ↑(onDiag h) (↑lfp (comp lfp h)) = ↑lfp (comp lfp h)

tactic: exact lfp_le _ h.onDiag.map_lfp.le
state_before: case refine'_1
α : Type u
β : Type v
γ : Type w
inst✝¹ : CompleteLattice α
inst✝ : CompleteLattice β
f : β →o α
g : α →o β
h : α →o α →o α
a : α := ↑lfp (comp lfp h)
⊢ ↑(comp lfp h) (↑lfp (onDiag h)) ≤ ↑lfp (onDiag h)
Theorem: Asymptotics.isLittleO_norm_right
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simp only [IsLittleO_def]
state_before: α : Type u_1
β : Type ?u.121013
E : Type u_2
F : Type ?u.121019
G : Type ?u.121022
E' : Type ?u.121025
F' : Type u_3
G' : Type ?u.121031
E'' : Type ?u.121034
F'' : Type ?u.121037
G'' : Type ?u.121040
R : Type ?u.121043
R' : Type ?u.121046
𝕜 : Type ?u.121049
𝕜' : Type ?u.121052
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 α
u v : α → ℝ
⊢ (f =o[l] fun x => ‖g' x‖) ↔ f =o[l] g'

tactic: exact forall₂_congr fun _ _ => isBigOWith_norm_right
state_before: α : Type u_1
β : Type ?u.121013
E : Type u_2
F : Type ?u.121019
G : Type ?u.121022
E' : Type ?u.121025
F' : Type u_3
G' : Type ?u.121031
E'' : Type ?u.121034
F'' : Type ?u.121037
G'' : Type ?u.121040
R : Type ?u.121043
R' : Type ?u.121046
𝕜 : Type ?u.121049
𝕜' : Type ?u.121052
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 α
u v : α → ℝ
⊢ (∀ ⦃c : ℝ⦄, 0 < c → IsBigOWith c l f fun x => ‖g' x‖) ↔ ∀ ⦃c : ℝ⦄, 0 < c → IsBigOWith c l f g'
Theorem: List.orderedInsert_count
File: Mathlib/Data/List/Sort.lean

tactic: rw [(L.perm_orderedInsert r b).count_eq, count_cons]
state_before: α : Type uu
r : α → α → Prop
inst✝¹ : DecidableRel r
inst✝ : DecidableEq α
L : List α
a b : α
⊢ count a (orderedInsert r b L) = count a L + if a = b then 1 else 0

tactic: split_ifs <;> simp only [Nat.succ_eq_add_one, add_zero]
state_before: α : Type uu
r : α → α → Prop
inst✝¹ : DecidableRel r
inst✝ : DecidableEq α
L : List α
a b : α
⊢ (if a = b then Nat.succ (count a L) else count a L) = count a L + if a = b then 1 else 0