tasksource/leandojo huggingface dataset:
Theorem: Turing.ToPartrec.Cont.then_eval
File: Mathlib/Computability/TMToPartrec.lean

tactic: induction' k with _ _ _ _ _ _ _ _ _ k_ih _ _ k_ih generalizing v <;>
  simp only [Cont.eval, Cont.then, bind_assoc, pure_bind, *]
state_before: k k' : Cont
v : List ℕ
⊢ eval (then k k') v = eval k v >>= eval k'

tactic: simp only [← k_ih]
state_before: case comp
k' : Cont
v✝ : List ℕ
a✝¹ : Code
a✝ : Cont
k_ih : ∀ {v : List ℕ}, eval (then a✝ k') v = eval a✝ v >>= eval k'
v : List ℕ
⊢ Code.eval a✝¹ v >>= eval (then a✝ k') = Code.eval a✝¹ v >>= fun x => eval a✝ x >>= eval k'

tactic: split_ifs <;> [rfl; simp only [← k_ih, bind_assoc]]
state_before: case fix
k' : Cont
v✝ : List ℕ
a✝¹ : Code
a✝ : Cont
k_ih : ∀ {v : List ℕ}, eval (then a✝ k') v = eval a✝ v >>= eval k'
v : List ℕ
⊢ (if List.headI v = 0 then eval a✝ (List.tail v) >>= eval k'
    else Code.eval (Code.fix a✝¹) (List.tail v) >>= eval (then a✝ k')) =
    (if List.headI v = 0 then eval a✝ (List.tail v) else Code.eval (Code.fix a✝¹) (List.tail v) >>= eval a✝) >>= eval k'
Theorem: eq_div_of_mul_eq''
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp [h.symm]
state_before: α : Type ?u.66484
β : Type ?u.66487
G : Type u_1
inst✝ : CommGroup G
a b c d : G
h : c * a = b
⊢ a = b / c
Theorem: Stream'.take_theorem
File: Mathlib/Data/Stream/Init.lean

tactic: intro h
state_before: α : Type u
β : Type v
δ : Type w
s₁ s₂ : Stream' α
⊢ (∀ (n : ℕ), take n s₁ = take n s₂) → s₁ = s₂

tactic: apply Stream'.ext
state_before: α : Type u
β : Type v
δ : Type w
s₁ s₂ : Stream' α
h : ∀ (n : ℕ), take n s₁ = take n s₂
⊢ s₁ = s₂

tactic: intro n
state_before: case a
α : Type u
β : Type v
δ : Type w
s₁ s₂ : Stream' α
h : ∀ (n : ℕ), take n s₁ = take n s₂
⊢ ∀ (n : ℕ), nth s₁ n = nth s₂ n

tactic: induction' n with n _
state_before: case a
α : Type u
β : Type v
δ : Type w
s₁ s₂ : Stream' α
h : ∀ (n : ℕ), take n s₁ = take n s₂
n : ℕ
⊢ nth s₁ n = nth s₂ n

tactic: have aux := h 1
state_before: case a.zero
α : Type u
β : Type v
δ : Type w
s₁ s₂ : Stream' α
h : ∀ (n : ℕ), take n s₁ = take n s₂
⊢ nth s₁ zero = nth s₂ zero

tactic: simp [take] at aux
state_before: case a.zero
α : Type u
β : Type v
δ : Type w
s₁ s₂ : Stream' α
h : ∀ (n : ℕ), take n s₁ = take n s₂
aux : take 1 s₁ = take 1 s₂
⊢ nth s₁ zero = nth s₂ zero

tactic: exact aux
state_before: case a.zero
α : Type u
β : Type v
δ : Type w
s₁ s₂ : Stream' α
h : ∀ (n : ℕ), take n s₁ = take n s₂
aux : head s₁ = head s₂
⊢ nth s₁ zero = nth s₂ zero

tactic: have h₁ : some (nth s₁ (succ n)) = some (nth s₂ (succ n)) := by
  rw [← get?_take_succ, ← get?_take_succ, h (succ (succ n))]
state_before: case a.succ
α : Type u
β : Type v
δ : Type w
s₁ s₂ : Stream' α
h : ∀ (n : ℕ), take n s₁ = take n s₂
n : ℕ
n_ih✝ : nth s₁ n = nth s₂ n
⊢ nth s₁ (succ n) = nth s₂ (succ n)

tactic: injection h₁
state_before: case a.succ
α : Type u
β : Type v
δ : Type w
s₁ s₂ : Stream' α
h : ∀ (n : ℕ), take n s₁ = take n s₂
n : ℕ
n_ih✝ : nth s₁ n = nth s₂ n
h₁ : some (nth s₁ (succ n)) = some (nth s₂ (succ n))
⊢ nth s₁ (succ n) = nth s₂ (succ n)

tactic: rw [← get?_take_succ, ← get?_take_succ, h (succ (succ n))]
state_before: α : Type u
β : Type v
δ : Type w
s₁ s₂ : Stream' α
h : ∀ (n : ℕ), take n s₁ = take n s₂
n : ℕ
n_ih✝ : nth s₁ n = nth s₂ n
⊢ some (nth s₁ (succ n)) = some (nth s₂ (succ n))
Theorem: IsGroupHom.inv_ker_one'
File: Mathlib/Deprecated/Subgroup.lean

tactic: have : (f a)⁻¹ * f b = 1 := by rw [h, mul_left_inv]
state_before: G : Type u_1
H : Type u_2
A : Type ?u.77638
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
a b : G
h : f a = f b
⊢ f (a⁻¹ * b) = 1

tactic: rwa [← hf.map_inv, ← hf.map_mul] at this
state_before: G : Type u_1
H : Type u_2
A : Type ?u.77638
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
a b : G
h : f a = f b
this : (f a)⁻¹ * f b = 1
⊢ f (a⁻¹ * b) = 1

tactic: rw [h, mul_left_inv]
state_before: G : Type u_1
H : Type u_2
A : Type ?u.77638
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
a b : G
h : f a = f b
⊢ (f a)⁻¹ * f b = 1
Theorem: affineSpan_convexHull
File: Mathlib/Analysis/Convex/Hull.lean

tactic: refine' le_antisymm _ (affineSpan_mono 𝕜 (subset_convexHull 𝕜 s))
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.45458
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
⊢ affineSpan 𝕜 (↑(convexHull 𝕜).toOrderHom s) = affineSpan 𝕜 s

tactic: rw [affineSpan_le]
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.45458
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
⊢ affineSpan 𝕜 (↑(convexHull 𝕜).toOrderHom s) ≤ affineSpan 𝕜 s

tactic: exact convexHull_subset_affineSpan s
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.45458
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
⊢ ↑(convexHull 𝕜).toOrderHom s ⊆ ↑(affineSpan 𝕜 s)
Theorem: CategoryTheory.Bicategory.unitors_inv_equal
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

tactic: simp [Iso.inv_eq_inv]
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
⊢ (λ_ (𝟙 a)).inv = (ρ_ (𝟙 a)).inv
Theorem: vectorSpan_eq_span_vsub_finset_right_ne
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: simp [vectorSpan_eq_span_vsub_set_right_ne _ (Finset.mem_coe.mpr hp)]
state_before: k : Type u_3
V : Type u_2
P : Type u_1
inst✝⁵ : Ring k
inst✝⁴ : AddCommGroup V
inst✝³ : Module k V
inst✝² : AffineSpace V P
ι : Type ?u.284656
inst✝¹ : DecidableEq P
inst✝ : DecidableEq V
s : Finset P
p : P
hp : p ∈ s
⊢ vectorSpan k ↑s = Submodule.span k ↑(Finset.image (fun x => x -ᵥ p) (Finset.erase s p))
Theorem: NNReal.pow_sum_div_card_le_sum_pow
File: Mathlib/Analysis/MeanInequalitiesPow.lean

tactic: simpa only [← NNReal.coe_le_coe, NNReal.coe_sum, Nonneg.coe_div, NNReal.coe_pow] using
  @Real.pow_sum_div_card_le_sum_pow ι s (((↑) : ℝ≥0 → ℝ) ∘ f) n fun _ _ => NNReal.coe_nonneg _
state_before: ι : Type u
s : Finset ι
f : ι → ℝ≥0
n : ℕ
⊢ ↑((∑ x in s, f x) ^ (n + 1)) / ↑(card s) ^ n ≤ ↑(∑ x in s, f x ^ (n + 1))
Theorem: List.support_formPerm_of_nodup
File: Mathlib/GroupTheory/Perm/List.lean

tactic: rw [← Finset.coe_inj]
state_before: α : Type u_1
β : Type ?u.766003
inst✝¹ : DecidableEq α
l✝ : List α
x : α
inst✝ : Fintype α
l : List α
h : Nodup l
h' : ∀ (x : α), l ≠ [x]
⊢ support (formPerm l) = toFinset l

tactic: convert support_formPerm_of_nodup' _ h h'
state_before: α : Type u_1
β : Type ?u.766003
inst✝¹ : DecidableEq α
l✝ : List α
x : α
inst✝ : Fintype α
l : List α
h : Nodup l
h' : ∀ (x : α), l ≠ [x]
⊢ ↑(support (formPerm l)) = ↑(toFinset l)

tactic: simp [Set.ext_iff]
state_before: case h.e'_2
α : Type u_1
β : Type ?u.766003
inst✝¹ : DecidableEq α
l✝ : List α
x : α
inst✝ : Fintype α
l : List α
h : Nodup l
h' : ∀ (x : α), l ≠ [x]
⊢ ↑(support (formPerm l)) = {x | ↑(formPerm l) x ≠ x}
Theorem: QuadraticForm.map_neg
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

tactic: rw [← @neg_one_smul R _ _ _ _ x, map_smul, neg_one_mul, neg_neg, one_mul]
state_before: S : Type ?u.139031
R : Type u_1
R₁ : Type ?u.139037
M : Type u_2
inst✝³ : Ring R
inst✝² : CommRing R₁
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
x : M
⊢ ↑Q (-x) = ↑Q x
Theorem: WithTop.image_coe_Ioi
File: Mathlib/Data/Set/Intervals/WithBotTop.lean

tactic: rw [← preimage_coe_Ioi, image_preimage_eq_inter_range, range_coe, Ioi_inter_Iio]
state_before: α : Type u_1
inst✝ : PartialOrder α
a b : α
⊢ some '' Ioi a = Ioo ↑a ⊤
Theorem: insert_mem_nhds_iff
File: Mathlib/Topology/ContinuousOn.lean

tactic: simp only [nhdsWithin, mem_inf_principal, mem_compl_iff, mem_singleton_iff, or_iff_not_imp_left,
  insert_def]
state_before: α : Type u_1
β : Type ?u.21904
γ : Type ?u.21907
δ : Type ?u.21910
inst✝ : TopologicalSpace α
a : α
s : Set α
⊢ insert a s ∈ 𝓝 a ↔ s ∈ 𝓝[{a}ᶜ] a
Theorem: CauSeq.Completion.ofRat_div
File: Mathlib/Data/Real/CauSeqCompletion.lean

tactic: simp only [div_eq_mul_inv, ofRat_inv, ofRat_mul]
state_before: α : Type u_2
inst✝² : LinearOrderedField α
β : Type u_1
inst✝¹ : DivisionRing β
abv : β → α
inst✝ : IsAbsoluteValue abv
x y : β
⊢ ofRat (x / y) = ofRat x / ofRat y
Theorem: affineIndependent_iff_of_fintype
File: Mathlib/LinearAlgebra/AffineSpace/Independent.lean

tactic: constructor
state_before: k : Type u_2
V : Type u_3
P : Type u_4
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
ι : Type u_1
inst✝ : Fintype ι
p : ι → P
⊢ AffineIndependent k p ↔
    ∀ (w : ι → k), ∑ i : ι, w i = 0 → ↑(Finset.weightedVSub Finset.univ p) w = 0 → ∀ (i : ι), w i = 0

tactic: exact fun h w hw hs i => h Finset.univ w hw hs i (Finset.mem_univ _)
state_before: case mp
k : Type u_2
V : Type u_3
P : Type u_4
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
ι : Type u_1
inst✝ : Fintype ι
p : ι → P
⊢ AffineIndependent k p →
    ∀ (w : ι → k), ∑ i : ι, w i = 0 → ↑(Finset.weightedVSub Finset.univ p) w = 0 → ∀ (i : ι), w i = 0

tactic: intro h s w hw hs i hi
state_before: case mpr
k : Type u_2
V : Type u_3
P : Type u_4
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
ι : Type u_1
inst✝ : Fintype ι
p : ι → P
⊢ (∀ (w : ι → k), ∑ i : ι, w i = 0 → ↑(Finset.weightedVSub Finset.univ p) w = 0 → ∀ (i : ι), w i = 0) →
    AffineIndependent k p

tactic: rw [Finset.weightedVSub_indicator_subset _ _ (Finset.subset_univ s)] at hs
state_before: case mpr
k : Type u_2
V : Type u_3
P : Type u_4
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
ι : Type u_1
inst✝ : Fintype ι
p : ι → P
h : ∀ (w : ι → k), ∑ i : ι, w i = 0 → ↑(Finset.weightedVSub Finset.univ p) w = 0 → ∀ (i : ι), w i = 0
s : Finset ι
w : ι → k
hw : ∑ i in s, w i = 0
hs : ↑(Finset.weightedVSub s p) w = 0
i : ι
hi : i ∈ s
⊢ w i = 0

tactic: rw [Set.sum_indicator_subset _ (Finset.subset_univ s)] at hw
state_before: case mpr
k : Type u_2
V : Type u_3
P : Type u_4
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
ι : Type u_1
inst✝ : Fintype ι
p : ι → P
h : ∀ (w : ι → k), ∑ i : ι, w i = 0 → ↑(Finset.weightedVSub Finset.univ p) w = 0 → ∀ (i : ι), w i = 0
s : Finset ι
w : ι → k
hw : ∑ i in s, w i = 0
hs : ↑(Finset.weightedVSub Finset.univ p) (Set.indicator (↑s) w) = 0
i : ι
hi : i ∈ s
⊢ w i = 0

tactic: replace h := h ((↑s : Set ι).indicator w) hw hs i
state_before: case mpr
k : Type u_2
V : Type u_3
P : Type u_4
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
ι : Type u_1
inst✝ : Fintype ι
p : ι → P
h : ∀ (w : ι → k), ∑ i : ι, w i = 0 → ↑(Finset.weightedVSub Finset.univ p) w = 0 → ∀ (i : ι), w i = 0
s : Finset ι
w : ι → k
hw : ∑ i : ι, Set.indicator (↑s) (fun i => w i) i = 0
hs : ↑(Finset.weightedVSub Finset.univ p) (Set.indicator (↑s) w) = 0
i : ι
hi : i ∈ s
⊢ w i = 0

tactic: simpa [hi] using h
state_before: case mpr
k : Type u_2
V : Type u_3
P : Type u_4
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
ι : Type u_1
inst✝ : Fintype ι
p : ι → P
s : Finset ι
w : ι → k
hw : ∑ i : ι, Set.indicator (↑s) (fun i => w i) i = 0
hs : ↑(Finset.weightedVSub Finset.univ p) (Set.indicator (↑s) w) = 0
i : ι
hi : i ∈ s
h : Set.indicator (↑s) w i = 0
⊢ w i = 0
Theorem: Seminorm.smul_closedBall_subset
File: Mathlib/Analysis/Seminorm.lean

tactic: rintro x ⟨y, hy, h⟩
state_before: R : Type ?u.1191905
R' : Type ?u.1191908
𝕜 : Type u_1
𝕜₂ : Type ?u.1191914
𝕜₃ : Type ?u.1191917
𝕝 : Type ?u.1191920
E : Type u_2
E₂ : Type ?u.1191926
E₃ : Type ?u.1191929
F : Type ?u.1191932
G : Type ?u.1191935
ι : Type ?u.1191938
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p✝ : Seminorm 𝕜 E
A B : Set E
a : 𝕜
r✝ : ℝ
x : E
p : Seminorm 𝕜 E
k : 𝕜
r : ℝ
⊢ k • closedBall p 0 r ⊆ closedBall p 0 (‖k‖ * r)

tactic: rw [Seminorm.mem_closedBall_zero, ← h, map_smul_eq_mul]
state_before: case intro.intro
R : Type ?u.1191905
R' : Type ?u.1191908
𝕜 : Type u_1
𝕜₂ : Type ?u.1191914
𝕜₃ : Type ?u.1191917
𝕝 : Type ?u.1191920
E : Type u_2
E₂ : Type ?u.1191926
E₃ : Type ?u.1191929
F : Type ?u.1191932
G : Type ?u.1191935
ι : Type ?u.1191938
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p✝ : Seminorm 𝕜 E
A B : Set E
a : 𝕜
r✝ : ℝ
x✝ : E
p : Seminorm 𝕜 E
k : 𝕜
r : ℝ
x y : E
hy : y ∈ closedBall p 0 r
h : (fun x => k • x) y = x
⊢ x ∈ closedBall p 0 (‖k‖ * r)

tactic: rw [Seminorm.mem_closedBall_zero] at hy
state_before: case intro.intro
R : Type ?u.1191905
R' : Type ?u.1191908
𝕜 : Type u_1
𝕜₂ : Type ?u.1191914
𝕜₃ : Type ?u.1191917
𝕝 : Type ?u.1191920
E : Type u_2
E₂ : Type ?u.1191926
E₃ : Type ?u.1191929
F : Type ?u.1191932
G : Type ?u.1191935
ι : Type ?u.1191938
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p✝ : Seminorm 𝕜 E
A B : Set E
a : 𝕜
r✝ : ℝ
x✝ : E
p : Seminorm 𝕜 E
k : 𝕜
r : ℝ
x y : E
hy : y ∈ closedBall p 0 r
h : (fun x => k • x) y = x
⊢ ‖k‖ * ↑p y ≤ ‖k‖ * r

tactic: gcongr
state_before: case intro.intro
R : Type ?u.1191905
R' : Type ?u.1191908
𝕜 : Type u_1
𝕜₂ : Type ?u.1191914
𝕜₃ : Type ?u.1191917
𝕝 : Type ?u.1191920
E : Type u_2
E₂ : Type ?u.1191926
E₃ : Type ?u.1191929
F : Type ?u.1191932
G : Type ?u.1191935
ι : Type ?u.1191938
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p✝ : Seminorm 𝕜 E
A B : Set E
a : 𝕜
r✝ : ℝ
x✝ : E
p : Seminorm 𝕜 E
k : 𝕜
r : ℝ
x y : E
hy : ↑p y ≤ r
h : (fun x => k • x) y = x
⊢ ‖k‖ * ↑p y ≤ ‖k‖ * r
Theorem: IsCompact.measure_zero_of_nhdsWithin
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: simpa only [← compl_mem_ae_iff] using hs.compl_mem_sets_of_nhdsWithin
state_before: α : Type u_1
β : Type ?u.3763501
γ : Type ?u.3763504
δ : Type ?u.3763507
ι : Type ?u.3763510
R : Type ?u.3763513
R' : Type ?u.3763516
inst✝¹ : TopologicalSpace α
inst✝ : MeasurableSpace α
μ : MeasureTheory.Measure α
s : Set α
hs : IsCompact s
⊢ (∀ (a : α), a ∈ s → ∃ t, t ∈ 𝓝[s] a ∧ ↑↑μ t = 0) → ↑↑μ s = 0
Theorem: toIocDiv_sub
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: simpa only [one_zsmul] using toIocDiv_sub_zsmul hp a b 1
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIocDiv hp a (b - p) = toIocDiv hp a b - 1
Theorem: Rel.edgeDensity_le_one
File: Mathlib/Combinatorics/SimpleGraph/Density.lean

tactic: apply div_le_one_of_le
state_before: 𝕜 : Type ?u.16981
ι : Type ?u.16984
κ : Type ?u.16987
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
s : Finset α
t : Finset β
⊢ edgeDensity r s t ≤ 1

tactic: exact_mod_cast card_interedges_le_mul r s t
state_before: case h
𝕜 : Type ?u.16981
ι : Type ?u.16984
κ : Type ?u.16987
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
s : Finset α
t : Finset β
⊢ ↑(card (interedges r s t)) ≤ ↑(card s) * ↑(card t)

tactic: exact_mod_cast Nat.zero_le _
state_before: case hb
𝕜 : Type ?u.16981
ι : Type ?u.16984
κ : Type ?u.16987
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
s : Finset α
t : Finset β
⊢ 0 ≤ ↑(card s) * ↑(card t)
Theorem: CommRingCat.pushoutCocone_pt
File: Mathlib/Algebra/Category/Ring/Constructions.lean

tactic: letI := f.toAlgebra
state_before: R A B : CommRingCat
f : R ⟶ A
g : R ⟶ B
⊢ CommRingCat

tactic: letI := g.toAlgebra
state_before: R A B : CommRingCat
f : R ⟶ A
g : R ⟶ B
this : Algebra ↑R ↑A := RingHom.toAlgebra f
⊢ CommRingCat

tactic: exact CommRingCat.of (A ⊗[R] B)
state_before: R A B : CommRingCat
f : R ⟶ A
g : R ⟶ B
this✝ : Algebra ↑R ↑A := RingHom.toAlgebra f
this : Algebra ↑R ↑B := RingHom.toAlgebra g
⊢ CommRingCat
Theorem: Multiset.le_bind
File: Mathlib/Data/Multiset/Bind.lean

tactic: classical
  rw [le_iff_count]
  intro a
  rw [count_bind]
  apply le_sum_of_mem
  rw [mem_map]
  exact ⟨x, hx, rfl⟩
state_before: α✝ : Type ?u.53011
β✝ : Type ?u.53014
γ : Type ?u.53017
δ : Type ?u.53020
a : α✝
s t : Multiset α✝
f✝ g : α✝ → Multiset β✝
α : Type u_1
β : Type u_2
f : α → Multiset β
S : Multiset α
x : α
hx : x ∈ S
⊢ f x ≤ bind S f

tactic: rw [le_iff_count]
state_before: α✝ : Type ?u.53011
β✝ : Type ?u.53014
γ : Type ?u.53017
δ : Type ?u.53020
a : α✝
s t : Multiset α✝
f✝ g : α✝ → Multiset β✝
α : Type u_1
β : Type u_2
f : α → Multiset β
S : Multiset α
x : α
hx : x ∈ S
⊢ f x ≤ bind S f

tactic: intro a
state_before: α✝ : Type ?u.53011
β✝ : Type ?u.53014
γ : Type ?u.53017
δ : Type ?u.53020
a : α✝
s t : Multiset α✝
f✝ g : α✝ → Multiset β✝
α : Type u_1
β : Type u_2
f : α → Multiset β
S : Multiset α
x : α
hx : x ∈ S
⊢ ∀ (a : β), count a (f x) ≤ count a (bind S f)

tactic: rw [count_bind]
state_before: α✝ : Type ?u.53011
β✝ : Type ?u.53014
γ : Type ?u.53017
δ : Type ?u.53020
a✝ : α✝
s t : Multiset α✝
f✝ g : α✝ → Multiset β✝
α : Type u_1
β : Type u_2
f : α → Multiset β
S : Multiset α
x : α
hx : x ∈ S
a : β
⊢ count a (f x) ≤ count a (bind S f)

tactic: apply le_sum_of_mem
state_before: α✝ : Type ?u.53011
β✝ : Type ?u.53014
γ : Type ?u.53017
δ : Type ?u.53020
a✝ : α✝
s t : Multiset α✝
f✝ g : α✝ → Multiset β✝
α : Type u_1
β : Type u_2
f : α → Multiset β
S : Multiset α
x : α
hx : x ∈ S
a : β
⊢ count a (f x) ≤ sum (map (fun b => count a (f b)) S)

tactic: rw [mem_map]
state_before: case h
α✝ : Type ?u.53011
β✝ : Type ?u.53014
γ : Type ?u.53017
δ : Type ?u.53020
a✝ : α✝
s t : Multiset α✝
f✝ g : α✝ → Multiset β✝
α : Type u_1
β : Type u_2
f : α → Multiset β
S : Multiset α
x : α
hx : x ∈ S
a : β
⊢ count a (f x) ∈ map (fun b => count a (f b)) S

tactic: exact ⟨x, hx, rfl⟩
state_before: case h
α✝ : Type ?u.53011
β✝ : Type ?u.53014
γ : Type ?u.53017
δ : Type ?u.53020
a✝ : α✝
s t : Multiset α✝
f✝ g : α✝ → Multiset β✝
α : Type u_1
β : Type u_2
f : α → Multiset β
S : Multiset α
x : α
hx : x ∈ S
a : β
⊢ ∃ a_1, a_1 ∈ S ∧ count a (f a_1) = count a (f x)
Theorem: Complex.IsExpCmpFilter.isLittleO_cpow_mul_exp
File: Mathlib/Analysis/SpecialFunctions/CompareExp.lean

tactic: simp only
state_before: l : Filter ℂ
b₁ b₂ : ℝ
hl : IsExpCmpFilter l
hb : b₁ < b₂
a₁ a₂ z : ℂ
hz : z ≠ 0
⊢ (fun z => z ^ a₁ * exp (↑b₁ * z)) z = (fun z => z ^ a₂ * exp (↑b₁ * z) * z ^ (a₁ - a₂)) z

tactic: rw [mul_right_comm, ← cpow_add _ _ hz, add_sub_cancel'_right]
state_before: l : Filter ℂ
b₁ b₂ : ℝ
hl : IsExpCmpFilter l
hb : b₁ < b₂
a₁ a₂ z : ℂ
hz : z ≠ 0
⊢ z ^ a₁ * exp (↑b₁ * z) = z ^ a₂ * exp (↑b₁ * z) * z ^ (a₁ - a₂)

tactic: simp only [ofReal_sub, sub_mul, mul_assoc, ← exp_add, add_sub_cancel'_right]
state_before: l : Filter ℂ
b₁ b₂ : ℝ
hl : IsExpCmpFilter l
hb : b₁ < b₂
a₁ a₂ : ℂ
⊢ (fun z => z ^ a₂ * exp (↑b₁ * z) * exp (↑(b₂ - b₁) * z)) =ᶠ[l] fun z => z ^ a₂ * exp (↑b₂ * z)

tactic: norm_cast
state_before: l : Filter ℂ
b₁ b₂ : ℝ
hl : IsExpCmpFilter l
hb : b₁ < b₂
a₁ a₂ : ℂ
⊢ (fun z => z ^ a₂ * exp (↑b₂ * z)) =ᶠ[l] fun z => z ^ a₂ * exp (↑b₂ * z)
Theorem: wittStructureRat_rec
File: Mathlib/RingTheory/WittVector/StructurePolynomial.lean

tactic: calc
  wittStructureRat p Φ n = C (1 / (p : ℚ) ^ n) * (wittStructureRat p Φ n * C ((p : ℚ) ^ n)) := ?_
  _ = _ := by rw [wittStructureRat_rec_aux]
state_before: p : ℕ
R : Type ?u.533445
idx : Type u_1
inst✝ : CommRing R
hp : Fact (Nat.Prime p)
Φ : MvPolynomial idx ℚ
n : ℕ
⊢ wittStructureRat p Φ n =
    ↑C (1 / ↑p ^ n) *
      (↑(bind₁ fun b => ↑(rename fun i => (b, i)) (W_ ℚ n)) Φ -
        ∑ i in Finset.range n, ↑C (↑p ^ i) * wittStructureRat p Φ i ^ p ^ (n - i))

tactic: rw [mul_left_comm, ← C_mul, div_mul_cancel, C_1, mul_one]
state_before: p : ℕ
R : Type ?u.533445
idx : Type u_1
inst✝ : CommRing R
hp : Fact (Nat.Prime p)
Φ : MvPolynomial idx ℚ
n : ℕ
⊢ wittStructureRat p Φ n = ↑C (1 / ↑p ^ n) * (wittStructureRat p Φ n * ↑C (↑p ^ n))

tactic: exact pow_ne_zero _ (Nat.cast_ne_zero.2 hp.1.ne_zero)
state_before: case h
p : ℕ
R : Type ?u.533445
idx : Type u_1
inst✝ : CommRing R
hp : Fact (Nat.Prime p)
Φ : MvPolynomial idx ℚ
n : ℕ
⊢ ↑p ^ n ≠ 0

tactic: rw [wittStructureRat_rec_aux]
state_before: p : ℕ
R : Type ?u.533445
idx : Type u_1
inst✝ : CommRing R
hp : Fact (Nat.Prime p)
Φ : MvPolynomial idx ℚ
n : ℕ
⊢ ↑C (1 / ↑p ^ n) * (wittStructureRat p Φ n * ↑C (↑p ^ n)) =
    ↑C (1 / ↑p ^ n) *
      (↑(bind₁ fun b => ↑(rename fun i => (b, i)) (W_ ℚ n)) Φ -
        ∑ i in Finset.range n, ↑C (↑p ^ i) * wittStructureRat p Φ i ^ p ^ (n - i))
Theorem: Set.mem_prod_list_ofFn
File: Mathlib/Data/Set/Pointwise/ListOfFn.lean

tactic: induction' n with n ih generalizing a
state_before: F : Type ?u.41
α : Type u_1
β : Type ?u.47
γ : Type ?u.50
inst✝ : Monoid α
s✝ t : Set α
a✝ : α
m n : ℕ
a : α
s : Fin n → Set α
⊢ a ∈ List.prod (List.ofFn s) ↔ ∃ f, List.prod (List.ofFn fun i => ↑(f i)) = a

tactic: simp_rw [List.ofFn_zero, List.prod_nil, Fin.exists_fin_zero_pi, eq_comm, Set.mem_one]
state_before: case zero
F : Type ?u.41
α : Type u_1
β : Type ?u.47
γ : Type ?u.50
inst✝ : Monoid α
s✝¹ t : Set α
a✝¹ : α
m n : ℕ
a✝ : α
s✝ : Fin n → Set α
a : α
s : Fin Nat.zero → Set α
⊢ a ∈ List.prod (List.ofFn s) ↔ ∃ f, List.prod (List.ofFn fun i => ↑(f i)) = a

tactic: simp_rw [List.ofFn_succ, List.prod_cons, Fin.exists_fin_succ_pi, Fin.cons_zero, Fin.cons_succ,
  mem_mul, @ih, exists_and_left, exists_exists_eq_and, SetCoe.exists, exists_prop]
state_before: case succ
F : Type ?u.41
α : Type u_1
β : Type ?u.47
γ : Type ?u.50
inst✝ : Monoid α
s✝¹ t : Set α
a✝¹ : α
m n✝ : ℕ
a✝ : α
s✝ : Fin n✝ → Set α
n : ℕ
ih : ∀ {a : α} {s : Fin n → Set α}, a ∈ List.prod (List.ofFn s) ↔ ∃ f, List.prod (List.ofFn fun i => ↑(f i)) = a
a : α
s : Fin (Nat.succ n) → Set α
⊢ a ∈ List.prod (List.ofFn s) ↔ ∃ f, List.prod (List.ofFn fun i => ↑(f i)) = a