tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.FiniteMeasure.tendsto_iff_forall_lintegral_tendsto
File: Mathlib/MeasureTheory/Measure/FiniteMeasure.lean

tactic: rw [tendsto_iff_forall_toWeakDualBCNN_tendsto]
state_before: Ω : Type u_2
inst✝⁶ : MeasurableSpace Ω
R : Type ?u.153372
inst✝⁵ : SMul R ℝ≥0
inst✝⁴ : SMul R ℝ≥0∞
inst✝³ : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝² : IsScalarTower R ℝ≥0∞ ℝ≥0∞
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
γ : Type u_1
F : Filter γ
μs : γ → FiniteMeasure Ω
μ : FiniteMeasure Ω
⊢ Tendsto μs F (𝓝 μ) ↔ ∀ (f : Ω →ᵇ ℝ≥0), Tendsto (fun i => ∫⁻ (x : Ω), ↑(↑f x) ∂↑(μs i)) F (𝓝 (∫⁻ (x : Ω), ↑(↑f x) ∂↑μ))

tactic: simp_rw [toWeakDualBCNN_apply _ _, ← testAgainstNN_coe_eq, ENNReal.tendsto_coe,
  ENNReal.toNNReal_coe]
state_before: Ω : Type u_2
inst✝⁶ : MeasurableSpace Ω
R : Type ?u.153372
inst✝⁵ : SMul R ℝ≥0
inst✝⁴ : SMul R ℝ≥0∞
inst✝³ : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝² : IsScalarTower R ℝ≥0∞ ℝ≥0∞
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
γ : Type u_1
F : Filter γ
μs : γ → FiniteMeasure Ω
μ : FiniteMeasure Ω
⊢ (∀ (f : Ω →ᵇ ℝ≥0), Tendsto (fun i => ↑(toWeakDualBCNN (μs i)) f) F (𝓝 (↑(toWeakDualBCNN μ) f))) ↔
    ∀ (f : Ω →ᵇ ℝ≥0), Tendsto (fun i => ∫⁻ (x : Ω), ↑(↑f x) ∂↑(μs i)) F (𝓝 (∫⁻ (x : Ω), ↑(↑f x) ∂↑μ))
Theorem: MonoidAlgebra.support_gen_of_gen'
File: Mathlib/RingTheory/FiniteType.lean

tactic: suffices (of R M '' ⋃ f ∈ S, (f.support : Set M)) = ⋃ f ∈ S, of R M '' (f.support : Set M) by
  rw [this]
  exact support_gen_of_gen hS
state_before: R : Type u_2
M : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Monoid M
S : Set (MonoidAlgebra R M)
hS : adjoin R S = ⊤
⊢ adjoin R (↑(of R M) '' ⋃ (f : MonoidAlgebra R M) (_ : f ∈ S), ↑f.support) = ⊤

tactic: simp only [Set.image_iUnion]
state_before: R : Type u_2
M : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Monoid M
S : Set (MonoidAlgebra R M)
hS : adjoin R S = ⊤
⊢ (↑(of R M) '' ⋃ (f : MonoidAlgebra R M) (_ : f ∈ S), ↑f.support) =
    ⋃ (f : MonoidAlgebra R M) (_ : f ∈ S), ↑(of R M) '' ↑f.support

tactic: rw [this]
state_before: R : Type u_2
M : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Monoid M
S : Set (MonoidAlgebra R M)
hS : adjoin R S = ⊤
this :
  (↑(of R M) '' ⋃ (f : MonoidAlgebra R M) (_ : f ∈ S), ↑f.support) =
    ⋃ (f : MonoidAlgebra R M) (_ : f ∈ S), ↑(of R M) '' ↑f.support
⊢ adjoin R (↑(of R M) '' ⋃ (f : MonoidAlgebra R M) (_ : f ∈ S), ↑f.support) = ⊤

tactic: exact support_gen_of_gen hS
state_before: R : Type u_2
M : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Monoid M
S : Set (MonoidAlgebra R M)
hS : adjoin R S = ⊤
this :
  (↑(of R M) '' ⋃ (f : MonoidAlgebra R M) (_ : f ∈ S), ↑f.support) =
    ⋃ (f : MonoidAlgebra R M) (_ : f ∈ S), ↑(of R M) '' ↑f.support
⊢ adjoin R (⋃ (f : MonoidAlgebra R M) (_ : f ∈ S), ↑(of R M) '' ↑f.support) = ⊤
Theorem: Set.mulIndicator_eq_self_of_superset
File: Mathlib/Algebra/IndicatorFunction.lean

tactic: rw [mulIndicator_eq_self] at h1⊢
state_before: α : Type u_1
β : Type ?u.3809
ι : Type ?u.3812
M : Type u_2
N : Type ?u.3818
inst✝¹ : One M
inst✝ : One N
s t : Set α
f g : α → M
a : α
h1 : mulIndicator s f = f
h2 : s ⊆ t
⊢ mulIndicator t f = f

tactic: exact Subset.trans h1 h2
state_before: α : Type u_1
β : Type ?u.3809
ι : Type ?u.3812
M : Type u_2
N : Type ?u.3818
inst✝¹ : One M
inst✝ : One N
s t : Set α
f g : α → M
a : α
h1 : mulSupport f ⊆ s
h2 : s ⊆ t
⊢ mulSupport f ⊆ t
Theorem: CircleDeg1Lift.le_iterate_pos_iff
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: simpa only [not_lt] using not_congr (f.iterate_pos_lt_iff hn)
state_before: f g : CircleDeg1Lift
x : ℝ
m : ℤ
n : ℕ
hn : 0 < n
⊢ x + ↑n * ↑m ≤ (↑f^[n]) x ↔ x + ↑m ≤ ↑f x
Theorem: List.exists_chain_of_relationReflTransGen
File: Mathlib/Data/List/Chain.lean

tactic: refine' Relation.ReflTransGen.head_induction_on h _ _
state_before: α : Type u
β : Type v
R r : α → α → Prop
l l₁ l₂ : List α
a b : α
h : Relation.ReflTransGen r a b
⊢ ∃ l, Chain r a l ∧ getLast (a :: l) (_ : a :: l ≠ []) = b

tactic: exact ⟨[], Chain.nil, rfl⟩
state_before: case refine'_1
α : Type u
β : Type v
R r : α → α → Prop
l l₁ l₂ : List α
a b : α
h : Relation.ReflTransGen r a b
⊢ ∃ l, Chain r b l ∧ getLast (b :: l) (_ : b :: l ≠ []) = b

tactic: intro c d e _ ih
state_before: case refine'_2
α : Type u
β : Type v
R r : α → α → Prop
l l₁ l₂ : List α
a b : α
h : Relation.ReflTransGen r a b
⊢ ∀ {a c : α},
    r a c →
      Relation.ReflTransGen r c b →
        (∃ l, Chain r c l ∧ getLast (c :: l) (_ : c :: l ≠ []) = b) →
          ∃ l, Chain r a l ∧ getLast (a :: l) (_ : a :: l ≠ []) = b

tactic: obtain ⟨l, hl₁, hl₂⟩ := ih
state_before: case refine'_2
α : Type u
β : Type v
R r : α → α → Prop
l l₁ l₂ : List α
a b : α
h : Relation.ReflTransGen r a b
c d : α
e : r c d
h✝ : Relation.ReflTransGen r d b
ih : ∃ l, Chain r d l ∧ getLast (d :: l) (_ : d :: l ≠ []) = b
⊢ ∃ l, Chain r c l ∧ getLast (c :: l) (_ : c :: l ≠ []) = b

tactic: refine' ⟨d :: l, Chain.cons e hl₁, _⟩
state_before: case refine'_2.intro.intro
α : Type u
β : Type v
R r : α → α → Prop
l✝ l₁ l₂ : List α
a b : α
h : Relation.ReflTransGen r a b
c d : α
e : r c d
h✝ : Relation.ReflTransGen r d b
l : List α
hl₁ : Chain r d l
hl₂ : getLast (d :: l) (_ : d :: l ≠ []) = b
⊢ ∃ l, Chain r c l ∧ getLast (c :: l) (_ : c :: l ≠ []) = b

tactic: rwa [getLast_cons_cons]
state_before: case refine'_2.intro.intro
α : Type u
β : Type v
R r : α → α → Prop
l✝ l₁ l₂ : List α
a b : α
h : Relation.ReflTransGen r a b
c d : α
e : r c d
h✝ : Relation.ReflTransGen r d b
l : List α
hl₁ : Chain r d l
hl₂ : getLast (d :: l) (_ : d :: l ≠ []) = b
⊢ getLast (c :: d :: l) (_ : c :: d :: l ≠ []) = b
Theorem: Acc.cutExpand
File: Mathlib/Logic/Hydra.lean

tactic: induction' hacc with a h ih
state_before: α : Type u_1
r : α → α → Prop
inst✝ : IsIrrefl α r
a : α
hacc : Acc r a
⊢ Acc (CutExpand r) {a}

tactic: refine' Acc.intro _ fun s ↦ _
state_before: case intro
α : Type u_1
r : α → α → Prop
inst✝ : IsIrrefl α r
a✝ a : α
h : ∀ (y : α), r y a → Acc r y
ih : ∀ (y : α), r y a → Acc (CutExpand r) {y}
⊢ Acc (CutExpand r) {a}

tactic: classical
simp only [cutExpand_iff, mem_singleton]
rintro ⟨t, a, hr, rfl, rfl⟩
refine' acc_of_singleton fun a' ↦ _
rw [erase_singleton, zero_add]
exact ih a' ∘ hr a'
state_before: case intro
α : Type u_1
r : α → α → Prop
inst✝ : IsIrrefl α r
a✝ a : α
h : ∀ (y : α), r y a → Acc r y
ih : ∀ (y : α), r y a → Acc (CutExpand r) {y}
s : Multiset α
⊢ CutExpand r s {a} → Acc (CutExpand r) s

tactic: simp only [cutExpand_iff, mem_singleton]
state_before: case intro
α : Type u_1
r : α → α → Prop
inst✝ : IsIrrefl α r
a✝ a : α
h : ∀ (y : α), r y a → Acc r y
ih : ∀ (y : α), r y a → Acc (CutExpand r) {y}
s : Multiset α
⊢ CutExpand r s {a} → Acc (CutExpand r) s

tactic: rintro ⟨t, a, hr, rfl, rfl⟩
state_before: case intro
α : Type u_1
r : α → α → Prop
inst✝ : IsIrrefl α r
a✝ a : α
h : ∀ (y : α), r y a → Acc r y
ih : ∀ (y : α), r y a → Acc (CutExpand r) {y}
s : Multiset α
⊢ (∃ t a_1, (∀ (a' : α), a' ∈ t → r a' a_1) ∧ a_1 = a ∧ s = erase {a} a_1 + t) → Acc (CutExpand r) s

tactic: refine' acc_of_singleton fun a' ↦ _
state_before: case intro.intro.intro.intro.intro
α : Type u_1
r : α → α → Prop
inst✝ : IsIrrefl α r
a✝ : α
t : Multiset α
a : α
hr : ∀ (a' : α), a' ∈ t → r a' a
h : ∀ (y : α), r y a → Acc r y
ih : ∀ (y : α), r y a → Acc (CutExpand r) {y}
⊢ Acc (CutExpand r) (erase {a} a + t)

tactic: rw [erase_singleton, zero_add]
state_before: case intro.intro.intro.intro.intro
α : Type u_1
r : α → α → Prop
inst✝ : IsIrrefl α r
a✝ : α
t : Multiset α
a : α
hr : ∀ (a' : α), a' ∈ t → r a' a
h : ∀ (y : α), r y a → Acc r y
ih : ∀ (y : α), r y a → Acc (CutExpand r) {y}
a' : α
⊢ a' ∈ erase {a} a + t → Acc (CutExpand r) {a'}

tactic: exact ih a' ∘ hr a'
state_before: case intro.intro.intro.intro.intro
α : Type u_1
r : α → α → Prop
inst✝ : IsIrrefl α r
a✝ : α
t : Multiset α
a : α
hr : ∀ (a' : α), a' ∈ t → r a' a
h : ∀ (y : α), r y a → Acc r y
ih : ∀ (y : α), r y a → Acc (CutExpand r) {y}
a' : α
⊢ a' ∈ t → Acc (CutExpand r) {a'}
Theorem: Finset.filter_False
File: Mathlib/Data/Finset/Basic.lean

tactic: simp [mem_filter, and_false_iff]
state_before: α : Type u_1
β : Type ?u.321046
γ : Type ?u.321049
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
s : Finset α
a : α
⊢ a ∈ filter (fun x => False) s ↔ a ∈ ∅
Theorem: HahnSeries.SummableFamily.hsum_add
File: Mathlib/RingTheory/HahnSeries.lean

tactic: ext g
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddCommMonoid R
α : Type u_3
s t : SummableFamily Γ R α
⊢ hsum (s + t) = hsum s + hsum t

tactic: simp only [hsum_coeff, add_coeff, add_apply]
state_before: case coeff.h
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddCommMonoid R
α : Type u_3
s t : SummableFamily Γ R α
g : Γ
⊢ coeff (hsum (s + t)) g = coeff (hsum s + hsum t) g

tactic: exact finsum_add_distrib (s.finite_co_support _) (t.finite_co_support _)
state_before: case coeff.h
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddCommMonoid R
α : Type u_3
s t : SummableFamily Γ R α
g : Γ
⊢ (∑ᶠ (i : α), coeff (toFun s i) g + coeff (toFun t i) g) =
    (∑ᶠ (i : α), coeff (toFun s i) g) + ∑ᶠ (i : α), coeff (toFun t i) g
Theorem: pow_mul'
File: Mathlib/Algebra/GroupPower/Basic.lean

tactic: rw [Nat.mul_comm, pow_mul]
state_before: α : Type ?u.16765
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝¹ : Monoid M
inst✝ : AddMonoid A
a : M
m n : ℕ
⊢ a ^ (m * n) = (a ^ n) ^ m
Theorem: SemiconjBy.zpow_right
File: Mathlib/Algebra/GroupPower/Basic.lean

tactic: simp [zpow_ofNat, h.pow_right n]
state_before: α : Type ?u.114118
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : Group G
a x y : G
h : SemiconjBy a x y
n : ℕ
⊢ SemiconjBy a (x ^ ↑n) (y ^ ↑n)

tactic: simp only [zpow_negSucc, inv_right_iff]
state_before: α : Type ?u.114118
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : Group G
a x y : G
h : SemiconjBy a x y
n : ℕ
⊢ SemiconjBy a (x ^ Int.negSucc n) (y ^ Int.negSucc n)

tactic: apply pow_right h
state_before: α : Type ?u.114118
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : Group G
a x y : G
h : SemiconjBy a x y
n : ℕ
⊢ SemiconjBy a (x ^ (n + 1)) (y ^ (n + 1))
Theorem: String.Iterator.ValidFor.toEnd
File: Std/Data/String/Lemmas.lean

tactic: simp [Iterator.toEnd, h.toString]
state_before: l r : List Char
it : Iterator
h : ValidFor l r it
⊢ ValidFor (List.reverse r ++ l) [] (Iterator.toEnd it)

tactic: exact .of_eq _ (by simp [List.reverseAux_eq]) (by simp [Nat.add_comm])
state_before: l r : List Char
it : Iterator
h : ValidFor l r it
⊢ ValidFor (List.reverse r ++ l) [] { s := { data := List.reverseAux l r }, i := { byteIdx := utf8Len l + utf8Len r } }

tactic: simp [List.reverseAux_eq]
state_before: l r : List Char
it : Iterator
h : ValidFor l r it
⊢ { s := { data := List.reverseAux l r }, i := { byteIdx := utf8Len l + utf8Len r } }.s.data =
    List.reverseAux (List.reverse r ++ l) []

tactic: simp [Nat.add_comm]
state_before: l r : List Char
it : Iterator
h : ValidFor l r it
⊢ { s := { data := List.reverseAux l r }, i := { byteIdx := utf8Len l + utf8Len r } }.i.byteIdx =
    utf8Len (List.reverse r ++ l)
Theorem: BilinForm.polar_to_quadratic_form
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

tactic: simp only [add_assoc, add_sub_cancel', add_right, polar, add_left_inj, add_neg_cancel_left,
  add_left, sub_eq_add_neg _ (B y y), add_comm (B y x) _]
state_before: S : Type ?u.369777
R : Type u_1
R₁ : Type ?u.369783
M : Type u_2
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
B : BilinForm R M
x y : M
⊢ polar (fun x => bilin B x x) x y = bilin B x y + bilin B y x
Theorem: BddBelow.bddAbove_image2_of_bddAbove
File: Mathlib/Order/Bounds/Basic.lean

tactic: rintro ⟨a, ha⟩ ⟨b, hb⟩
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β → γ
s : Set α
t : Set β
a : α
b : β
h₀ : ∀ (b : β), Antitone (swap f b)
h₁ : ∀ (a : α), Monotone (f a)
⊢ BddBelow s → BddAbove t → BddAbove (Set.image2 f s t)

tactic: exact ⟨f a b, mem_upperBounds_image2_of_mem_upperBounds_of_mem_upperBounds h₀ h₁ ha hb⟩
state_before: case intro.intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β → γ
s : Set α
t : Set β
a✝ : α
b✝ : β
h₀ : ∀ (b : β), Antitone (swap f b)
h₁ : ∀ (a : α), Monotone (f a)
a : α
ha : a ∈ lowerBounds s
b : β
hb : b ∈ upperBounds t
⊢ BddAbove (Set.image2 f s t)
Theorem: Finsupp.embDomain_notin_range
File: Mathlib/Data/Finsupp/Defs.lean

tactic: classical
  refine' dif_neg (mt (fun h => _) h)
  rcases Finset.mem_map.1 h with ⟨a, _h, rfl⟩
  exact Set.mem_range_self a
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.218890
ι : Type ?u.218893
M : Type u_3
M' : Type ?u.218899
N : Type ?u.218902
P : Type ?u.218905
G : Type ?u.218908
H : Type ?u.218911
R : Type ?u.218914
S : Type ?u.218917
inst✝¹ : Zero M
inst✝ : Zero N
f : α ↪ β
v : α →₀ M
a : β
h : ¬a ∈ Set.range ↑f
⊢ ↑(embDomain f v) a = 0

tactic: refine' dif_neg (mt (fun h => _) h)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.218890
ι : Type ?u.218893
M : Type u_3
M' : Type ?u.218899
N : Type ?u.218902
P : Type ?u.218905
G : Type ?u.218908
H : Type ?u.218911
R : Type ?u.218914
S : Type ?u.218917
inst✝¹ : Zero M
inst✝ : Zero N
f : α ↪ β
v : α →₀ M
a : β
h : ¬a ∈ Set.range ↑f
⊢ ↑(embDomain f v) a = 0

tactic: rcases Finset.mem_map.1 h with ⟨a, _h, rfl⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.218890
ι : Type ?u.218893
M : Type u_3
M' : Type ?u.218899
N : Type ?u.218902
P : Type ?u.218905
G : Type ?u.218908
H : Type ?u.218911
R : Type ?u.218914
S : Type ?u.218917
inst✝¹ : Zero M
inst✝ : Zero N
f : α ↪ β
v : α →₀ M
a : β
h✝ : ¬a ∈ Set.range ↑f
h : a ∈ map f v.support
⊢ a ∈ Set.range ↑f

tactic: exact Set.mem_range_self a
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.218890
ι : Type ?u.218893
M : Type u_3
M' : Type ?u.218899
N : Type ?u.218902
P : Type ?u.218905
G : Type ?u.218908
H : Type ?u.218911
R : Type ?u.218914
S : Type ?u.218917
inst✝¹ : Zero M
inst✝ : Zero N
f : α ↪ β
v : α →₀ M
a : α
_h : a ∈ v.support
h✝ : ¬↑f a ∈ Set.range ↑f
h : ↑f a ∈ map f v.support
⊢ ↑f a ∈ Set.range ↑f
Theorem: pow_bit1'
File: Mathlib/Algebra/GroupPower/Basic.lean

tactic: rw [bit1, pow_succ', pow_bit0']
state_before: α : Type ?u.39154
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝¹ : Monoid M
inst✝ : AddMonoid A
a : M
n : ℕ
⊢ a ^ bit1 n = (a * a) ^ n * a
Theorem: FiniteField.expand_card
File: Mathlib/FieldTheory/Finite/Basic.lean

tactic: cases' CharP.exists K with p hp
state_before: K : Type u_1
R : Type ?u.820624
inst✝³ : Field K
inst✝² : Fintype K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Algebra (ZMod p) K
f : K[X]
⊢ ↑(expand K q) f = f ^ q

tactic: letI := hp
state_before: case intro
K : Type u_1
R : Type ?u.820624
inst✝³ : Field K
inst✝² : Fintype K
p✝ : ℕ
inst✝¹ : Fact (Nat.Prime p✝)
inst✝ : Algebra (ZMod p✝) K
f : K[X]
p : ℕ
hp : CharP K p
⊢ ↑(expand K q) f = f ^ q

tactic: rcases FiniteField.card K p with ⟨⟨n, npos⟩, ⟨hp, hn⟩⟩
state_before: case intro
K : Type u_1
R : Type ?u.820624
inst✝³ : Field K
inst✝² : Fintype K
p✝ : ℕ
inst✝¹ : Fact (Nat.Prime p✝)
inst✝ : Algebra (ZMod p✝) K
f : K[X]
p : ℕ
hp : CharP K p
this : CharP K p := hp
⊢ ↑(expand K q) f = f ^ q

tactic: haveI : Fact p.Prime := ⟨hp⟩
state_before: case intro.intro.mk.intro
K : Type u_1
R : Type ?u.820624
inst✝³ : Field K
inst✝² : Fintype K
p✝ : ℕ
inst✝¹ : Fact (Nat.Prime p✝)
inst✝ : Algebra (ZMod p✝) K
f : K[X]
p : ℕ
hp✝ : CharP K p
this : CharP K p := hp✝
n : ℕ
npos : 0 < n
hp : Nat.Prime p
hn : q = p ^ ↑{ val := n, property := npos }
⊢ ↑(expand K q) f = f ^ q

tactic: dsimp at hn
state_before: case intro.intro.mk.intro
K : Type u_1
R : Type ?u.820624
inst✝³ : Field K
inst✝² : Fintype K
p✝ : ℕ
inst✝¹ : Fact (Nat.Prime p✝)
inst✝ : Algebra (ZMod p✝) K
f : K[X]
p : ℕ
hp✝ : CharP K p
this✝ : CharP K p := hp✝
n : ℕ
npos : 0 < n
hp : Nat.Prime p
hn : q = p ^ ↑{ val := n, property := npos }
this : Fact (Nat.Prime p)
⊢ ↑(expand K q) f = f ^ q

tactic: rw [hn, ← map_expand_pow_char, frobenius_pow hn, RingHom.one_def, map_id]
state_before: case intro.intro.mk.intro
K : Type u_1
R : Type ?u.820624
inst✝³ : Field K
inst✝² : Fintype K
p✝ : ℕ
inst✝¹ : Fact (Nat.Prime p✝)
inst✝ : Algebra (ZMod p✝) K
f : K[X]
p : ℕ
hp✝ : CharP K p
this✝ : CharP K p := hp✝
n : ℕ
npos : 0 < n
hp : Nat.Prime p
hn : q = p ^ n
this : Fact (Nat.Prime p)
⊢ ↑(expand K q) f = f ^ q
Theorem: nhdsWithin_subtype_eq_bot_iff
File: Mathlib/Topology/Constructions.lean

tactic: rw [inf_principal_eq_bot_iff_comap, nhdsWithin, nhdsWithin, comap_inf, comap_principal,
  nhds_induced]
state_before: α : Type u
β : Type v
γ : Type ?u.11692
δ : Type ?u.11695
ε : Type ?u.11698
ζ : Type ?u.11701
inst✝ : TopologicalSpace α
s t : Set α
x : ↑s
⊢ 𝓝[Subtype.val ⁻¹' t] x = ⊥ ↔ 𝓝[t] ↑x ⊓ 𝓟 s = ⊥
Theorem: Equiv.Perm.SameCycle.of_pow
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: simp [zpow_mul, h]
state_before: ι : Type ?u.204487
α : Type u_1
β : Type ?u.204493
f g : Perm α
p : α → Prop
x y z : α
n : ℕ
x✝ : SameCycle (f ^ n) x y
m : ℤ
h : ↑((f ^ n) ^ m) x = y
⊢ ↑(f ^ (↑n * m)) x = y
Theorem: CategoryTheory.Functor.postcomp_map_hEq'
File: Mathlib/CategoryTheory/EqToHom.lean

tactic: rw [Functor.hext hobj fun _ _ => hmap]
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
E : Type u₃
inst✝ : Category E
F G : C ⥤ D
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
H : D ⥤ E
hobj : ∀ (X : C), F.obj X = G.obj X
hmap : ∀ {X Y : C} (f : X ⟶ Y), HEq (F.map f) (G.map f)
⊢ HEq ((F ⋙ H).map f) ((G ⋙ H).map f)
Theorem: Matrix.fromBlocks_multiply
File: Mathlib/Data/Matrix/Block.lean

tactic: ext i j
state_before: l : Type u_1
m : Type u_2
n : Type u_4
o : Type u_5
p : Type u_6
q : Type u_7
m' : o → Type ?u.37702
n' : o → Type ?u.37707
p' : o → Type ?u.37712
R : Type ?u.37715
S : Type ?u.37718
α : Type u_3
β : Type ?u.37724
inst✝² : Fintype l
inst✝¹ : Fintype m
inst✝ : NonUnitalNonAssocSemiring α
A : Matrix n l α
B : Matrix n m α
C : Matrix o l α
D : Matrix o m α
A' : Matrix l p α
B' : Matrix l q α
C' : Matrix m p α
D' : Matrix m q α
⊢ fromBlocks A B C D ⬝ fromBlocks A' B' C' D' =
    fromBlocks (A ⬝ A' + B ⬝ C') (A ⬝ B' + B ⬝ D') (C ⬝ A' + D ⬝ C') (C ⬝ B' + D ⬝ D')

tactic: rcases i with ⟨⟩ <;> rcases j with ⟨⟩ <;> simp only [fromBlocks, mul_apply, of_apply,
    Sum.elim_inr, Fintype.sum_sum_type, Sum.elim_inl, add_apply]
state_before: case a.h
l : Type u_1
m : Type u_2
n : Type u_4
o : Type u_5
p : Type u_6
q : Type u_7
m' : o → Type ?u.37702
n' : o → Type ?u.37707
p' : o → Type ?u.37712
R : Type ?u.37715
S : Type ?u.37718
α : Type u_3
β : Type ?u.37724
inst✝² : Fintype l
inst✝¹ : Fintype m
inst✝ : NonUnitalNonAssocSemiring α
A : Matrix n l α
B : Matrix n m α
C : Matrix o l α
D : Matrix o m α
A' : Matrix l p α
B' : Matrix l q α
C' : Matrix m p α
D' : Matrix m q α
i : n ⊕ o
j : p ⊕ q
⊢ (fromBlocks A B C D ⬝ fromBlocks A' B' C' D') i j =
    fromBlocks (A ⬝ A' + B ⬝ C') (A ⬝ B' + B ⬝ D') (C ⬝ A' + D ⬝ C') (C ⬝ B' + D ⬝ D') i j
Theorem: List.intersperse_eq_intersperseTR
File: Std/Data/List/Basic.lean

tactic: funext α sep l
state_before: ⊢ @intersperse = @intersperseTR

tactic: simp [intersperseTR]
state_before: case h.h.h
α : Type u_1
sep : α
l : List α
⊢ intersperse sep l = intersperseTR sep l

tactic: match l with
| [] | [_] => rfl
| x::y::xs => simp [intersperse]; induction xs generalizing y <;> simp [*]
state_before: case h.h.h
α : Type u_1
sep : α
l : List α
⊢ intersperse sep l =
    match l with
    | [] => []
    | [x] => [x]
    | x :: y :: xs => x :: sep :: y :: foldr (fun a r => sep :: a :: r) [] xs

tactic: rfl
state_before: α : Type u_1
sep : α
l : List α
head✝ : α
⊢ intersperse sep [head✝] =
    match [head✝] with
    | [] => []
    | [x] => [x]
    | x :: y :: xs => x :: sep :: y :: foldr (fun a r => sep :: a :: r) [] xs

tactic: simp [intersperse]
state_before: α : Type u_1
sep : α
l : List α
x y : α
xs : List α
⊢ intersperse sep (x :: y :: xs) =
    match x :: y :: xs with
    | [] => []
    | [x] => [x]
    | x :: y :: xs => x :: sep :: y :: foldr (fun a r => sep :: a :: r) [] xs

tactic: induction xs generalizing y <;> simp [*]
state_before: α : Type u_1
sep : α
l : List α
x y : α
xs : List α
⊢ intersperse sep (y :: xs) = y :: foldr (fun a r => sep :: a :: r) [] xs
Theorem: PadicSeq.norm_nonarchimedean_aux
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: unfold norm
state_before: p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
hfg : ¬f + g ≈ 0
hf : ¬f ≈ 0
hg : ¬g ≈ 0
⊢ norm (f + g) ≤ max (norm f) (norm g)

tactic: split_ifs
state_before: p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
hfg : ¬f + g ≈ 0
hf : ¬f ≈ 0
hg : ¬g ≈ 0
⊢ (if hf : f + g ≈ 0 then 0 else padicNorm p (↑(f + g) (stationaryPoint hf))) ≤
    max (if hf : f ≈ 0 then 0 else padicNorm p (↑f (stationaryPoint hf)))
      (if hf : g ≈ 0 then 0 else padicNorm p (↑g (stationaryPoint hf)))

tactic: rw [lift_index_left_left hfg, lift_index_left hf, lift_index_right hg]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
hfg : ¬f + g ≈ 0
hf : ¬f ≈ 0
hg : ¬g ≈ 0
⊢ padicNorm p (↑(f + g) (stationaryPoint hfg)) ≤
    max (padicNorm p (↑f (stationaryPoint hf))) (padicNorm p (↑g (stationaryPoint hg)))

tactic: apply padicNorm.nonarchimedean
state_before: p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
hfg : ¬f + g ≈ 0
hf : ¬f ≈ 0
hg : ¬g ≈ 0
⊢ padicNorm p (↑(f + g) (max (stationaryPoint hfg) (max ?v2 ?v3))) ≤
    max (padicNorm p (↑f (max ?v1 (max (stationaryPoint hf) ?v3))))
      (padicNorm p (↑g (max ?v1 (max ?v2 (stationaryPoint hg)))))

case v1
p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
hfg : ¬f + g ≈ 0
hf : ¬f ≈ 0
hg : ¬g ≈ 0
⊢ ℕ

case v2
p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
hfg : ¬f + g ≈ 0
hf : ¬f ≈ 0
hg : ¬g ≈ 0
⊢ ℕ

case v2
p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
hfg : ¬f + g ≈ 0
hf : ¬f ≈ 0
hg : ¬g ≈ 0
⊢ ℕ

case v3
p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
hfg : ¬f + g ≈ 0
hf : ¬f ≈ 0
hg : ¬g ≈ 0
⊢ ℕ

case v1
p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
hfg : ¬f + g ≈ 0
hf : ¬f ≈ 0
hg : ¬g ≈ 0
⊢ ℕ

case v3
p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
hfg : ¬f + g ≈ 0
hf : ¬f ≈ 0
hg : ¬g ≈ 0
⊢ ℕ

case v1
p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
hfg : ¬f + g ≈ 0
hf : ¬f ≈ 0
hg : ¬g ≈ 0
⊢ ℕ

case v3
p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
hfg : ¬f + g ≈ 0
hf : ¬f ≈ 0
hg : ¬g ≈ 0
⊢ ℕ

case v2
p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
hfg : ¬f + g ≈ 0
hf : ¬f ≈ 0
hg : ¬g ≈ 0
⊢ ℕ

case v3
p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
hfg : ¬f + g ≈ 0
hf : ¬f ≈ 0
hg : ¬g ≈ 0
⊢ ℕ

case v2
p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
hfg : ¬f + g ≈ 0
hf : ¬f ≈ 0
hg : ¬g ≈ 0
⊢ ℕ

case v3
p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
hfg : ¬f + g ≈ 0
hf : ¬f ≈ 0
hg : ¬g ≈ 0
⊢ ℕ
Theorem: List.next_cons_cons_eq'
File: Mathlib/Data/List/Cycle.lean

tactic: rw [next, nextOr, if_pos hx]
state_before: α : Type u_1
inst✝ : DecidableEq α
l : List α
x y z : α
h : x ∈ y :: z :: l
hx : x = y
⊢ next (y :: z :: l) x h = z