tasksource/leandojo huggingface dataset:
Theorem: CommMonoid.torsion.isTorsion
File: Mathlib/GroupTheory/Torsion.lean

tactic: dsimp
state_before: G : Type u_1
H : Type ?u.178531
inst✝ : CommMonoid G
x✝ : { x // x ∈ torsion G }
x : G
n : ℕ
npos : n > 0
hn : Function.IsPeriodicPt ((fun x x_1 => x * x_1) x) n 1
⊢ ↑(((fun x x_1 => x * x_1)
            { val := x, property := (_ : ∃ n, n > 0 ∧ Function.IsPeriodicPt ((fun x x_1 => x * x_1) x) n 1) }^[n])
        1) =
    ↑1

tactic: rw [mul_left_iterate]
state_before: G : Type u_1
H : Type ?u.178531
inst✝ : CommMonoid G
x✝ : { x // x ∈ torsion G }
x : G
n : ℕ
npos : n > 0
hn : Function.IsPeriodicPt ((fun x x_1 => x * x_1) x) n 1
⊢ ↑(((fun x_1 => { val := x, property := (_ : ∃ n, n > 0 ∧ Function.IsPeriodicPt (fun x_2 => x * x_2) n 1) } * x_1)^[n])
        1) =
    1

tactic: change _ * 1 = 1
state_before: G : Type u_1
H : Type ?u.178531
inst✝ : CommMonoid G
x✝ : { x // x ∈ torsion G }
x : G
n : ℕ
npos : n > 0
hn : Function.IsPeriodicPt ((fun x x_1 => x * x_1) x) n 1
⊢ ↑((fun x_1 => { val := x, property := (_ : ∃ n, n > 0 ∧ Function.IsPeriodicPt (fun x_2 => x * x_2) n 1) } ^ n * x_1)
        1) =
    1

tactic: rw [_root_.mul_one, SubmonoidClass.coe_pow, Subtype.coe_mk,
  (isPeriodicPt_mul_iff_pow_eq_one _).mp hn]
state_before: G : Type u_1
H : Type ?u.178531
inst✝ : CommMonoid G
x✝ : { x // x ∈ torsion G }
x : G
n : ℕ
npos : n > 0
hn : Function.IsPeriodicPt ((fun x x_1 => x * x_1) x) n 1
⊢ ↑({ val := x, property := (_ : ∃ n, n > 0 ∧ Function.IsPeriodicPt (fun x_1 => x * x_1) n 1) } ^ n) * 1 = 1
Theorem: ultrafilter_isClosed_basic
File: Mathlib/Topology/StoneCech.lean

tactic: rw [← isOpen_compl_iff]
state_before: α : Type u
s : Set α
⊢ IsClosed {u | s ∈ u}

tactic: convert ultrafilter_isOpen_basic (sᶜ) using 1
state_before: α : Type u
s : Set α
⊢ IsOpen ({u | s ∈ u}ᶜ)

tactic: ext u
state_before: case h.e'_3
α : Type u
s : Set α
⊢ {u | s ∈ u}ᶜ = {u | sᶜ ∈ u}

tactic: exact Ultrafilter.compl_mem_iff_not_mem.symm
state_before: case h.e'_3.h
α : Type u
s : Set α
u : Ultrafilter α
⊢ u ∈ {u | s ∈ u}ᶜ ↔ u ∈ {u | sᶜ ∈ u}
Theorem: Ring.exists_list_of_mem_closure
File: Mathlib/Deprecated/Subring.lean

tactic: refine' List.recOn L1 neg_zero.symm fun hd tl ih ↦ _
state_before: R : Type u
inst✝¹ : Ring R
cR : Type u
inst✝ : CommRing cR
s : Set R
a : R
h : a ∈ closure s
b : R
ih : ∃ L, (∀ (l : List R), l ∈ L → ∀ (x : R), x ∈ l → x ∈ s ∨ x = -1) ∧ List.sum (List.map List.prod L) = b
L1 : List (List R)
h1 : ∀ (l : List R), l ∈ L1 → ∀ (x : R), x ∈ l → x ∈ s ∨ x = -1
x✝ : AddGroup.InClosure (Monoid.Closure s) (List.sum (List.map List.prod L1))
⊢ List.sum (List.map (fun x => -List.prod x) L1) = -List.sum (List.map List.prod L1)

tactic: rw [List.map_cons, List.sum_cons, ih, List.map_cons, List.sum_cons, neg_add]
state_before: R : Type u
inst✝¹ : Ring R
cR : Type u
inst✝ : CommRing cR
s : Set R
a : R
h : a ∈ closure s
b : R
ih✝ : ∃ L, (∀ (l : List R), l ∈ L → ∀ (x : R), x ∈ l → x ∈ s ∨ x = -1) ∧ List.sum (List.map List.prod L) = b
L1 : List (List R)
h1 : ∀ (l : List R), l ∈ L1 → ∀ (x : R), x ∈ l → x ∈ s ∨ x = -1
x✝ : AddGroup.InClosure (Monoid.Closure s) (List.sum (List.map List.prod L1))
hd : List R
tl : List (List R)
ih : List.sum (List.map (fun x => -List.prod x) tl) = -List.sum (List.map List.prod tl)
⊢ List.sum (List.map (fun x => -List.prod x) (hd :: tl)) = -List.sum (List.map List.prod (hd :: tl))

tactic: rw [List.map_append, List.sum_append]
state_before: R : Type u
inst✝¹ : Ring R
cR : Type u
inst✝ : CommRing cR
s : Set R
a : R
h : a ∈ closure s
r1 r2 : R
ih1 : ∃ L, (∀ (l : List R), l ∈ L → ∀ (x : R), x ∈ l → x ∈ s ∨ x = -1) ∧ List.sum (List.map List.prod L) = r1
ih2 : ∃ L, (∀ (l : List R), l ∈ L → ∀ (x : R), x ∈ l → x ∈ s ∨ x = -1) ∧ List.sum (List.map List.prod L) = r2
L1 : List (List R)
h1 : ∀ (l : List R), l ∈ L1 → ∀ (x : R), x ∈ l → x ∈ s ∨ x = -1
L2 : List (List R)
h2 : ∀ (l : List R), l ∈ L2 → ∀ (x : R), x ∈ l → x ∈ s ∨ x = -1
x✝¹ : AddGroup.InClosure (Monoid.Closure s) (List.sum (List.map List.prod L1))
x✝ : AddGroup.InClosure (Monoid.Closure s) (List.sum (List.map List.prod L2))
⊢ List.sum (List.map List.prod (L1 ++ L2)) = List.sum (List.map List.prod L1) + List.sum (List.map List.prod L2)
Theorem: Ideal.finite_mulSupport
File: Mathlib/RingTheory/DedekindDomain/Factorization.lean

tactic: intro v hv h_zero
state_before: R : Type u_1
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
inst✝³ : IsDedekindDomain R
K : Type ?u.12131
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
I : Ideal R
hI : I ≠ 0
⊢ {v | maxPowDividing v I ≠ 1} ⊆
    {v | ↑(Associates.count (Associates.mk v.asIdeal) (Associates.factors (Associates.mk I))) ≠ 0}

tactic: have hv' : v.maxPowDividing I = 1 := by
  rw [IsDedekindDomain.HeightOneSpectrum.maxPowDividing, Int.coe_nat_eq_zero.mp h_zero,
    pow_zero _]
state_before: R : Type u_1
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
inst✝³ : IsDedekindDomain R
K : Type ?u.12131
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v✝ : HeightOneSpectrum R
I : Ideal R
hI : I ≠ 0
v : HeightOneSpectrum R
hv : v ∈ {v | maxPowDividing v I ≠ 1}
h_zero : ↑(Associates.count (Associates.mk v.asIdeal) (Associates.factors (Associates.mk I))) = 0
⊢ False

tactic: exact hv hv'
state_before: R : Type u_1
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
inst✝³ : IsDedekindDomain R
K : Type ?u.12131
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v✝ : HeightOneSpectrum R
I : Ideal R
hI : I ≠ 0
v : HeightOneSpectrum R
hv : v ∈ {v | maxPowDividing v I ≠ 1}
h_zero : ↑(Associates.count (Associates.mk v.asIdeal) (Associates.factors (Associates.mk I))) = 0
hv' : maxPowDividing v I = 1
⊢ False

tactic: rw [IsDedekindDomain.HeightOneSpectrum.maxPowDividing, Int.coe_nat_eq_zero.mp h_zero,
  pow_zero _]
state_before: R : Type u_1
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
inst✝³ : IsDedekindDomain R
K : Type ?u.12131
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v✝ : HeightOneSpectrum R
I : Ideal R
hI : I ≠ 0
v : HeightOneSpectrum R
hv : v ∈ {v | maxPowDividing v I ≠ 1}
h_zero : ↑(Associates.count (Associates.mk v.asIdeal) (Associates.factors (Associates.mk I))) = 0
⊢ maxPowDividing v I = 1
Theorem: CategoryTheory.Biprod.ofComponents_fst
File: Mathlib/CategoryTheory/Preadditive/Biproducts.lean

tactic: simp [Biprod.ofComponents]
state_before: C : Type u
inst✝² : Category C
inst✝¹ : Preadditive C
inst✝ : HasBinaryBiproducts C
X₁ X₂ Y₁ Y₂ : C
f₁₁ : X₁ ⟶ Y₁
f₁₂ : X₁ ⟶ Y₂
f₂₁ : X₂ ⟶ Y₁
f₂₂ : X₂ ⟶ Y₂
⊢ ofComponents f₁₁ f₁₂ f₂₁ f₂₂ ≫ biprod.fst = biprod.fst ≫ f₁₁ + biprod.snd ≫ f₂₁
Theorem: IsROrC.conj_eq_re_sub_im
File: Mathlib/Data/IsROrC/Basic.lean

tactic: rw [map_add, map_mul, conj_I, conj_ofReal, conj_ofReal, mul_neg, sub_eq_add_neg]
state_before: K : Type u_1
E : Type ?u.2851475
inst✝ : IsROrC K
z : K
⊢ ↑(starRingEnd K) (↑(↑re z) + ↑(↑im z) * I) = ↑(↑re z) - ↑(↑im z) * I
Theorem: IsClosed.Icc_subset_of_forall_mem_nhdsWithin
File: Mathlib/Topology/Algebra/Order/IntermediateValue.lean

tactic: apply hs.Icc_subset_of_forall_exists_gt ha
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁷ : ConditionallyCompleteLinearOrder α
inst✝⁶ : TopologicalSpace α
inst✝⁵ : OrderTopology α
inst✝⁴ : ConditionallyCompleteLinearOrder β
inst✝³ : TopologicalSpace β
inst✝² : OrderTopology β
inst✝¹ : Nonempty γ
inst✝ : DenselyOrdered α
a✝ b✝ a b : α
s : Set α
hs : IsClosed (s ∩ Icc a b)
ha : a ∈ s
hgt : ∀ (x : α), x ∈ s ∩ Ico a b → s ∈ 𝓝[Ioi x] x
⊢ Icc a b ⊆ s

tactic: rintro x ⟨hxs, hxab⟩ y hyxb
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁷ : ConditionallyCompleteLinearOrder α
inst✝⁶ : TopologicalSpace α
inst✝⁵ : OrderTopology α
inst✝⁴ : ConditionallyCompleteLinearOrder β
inst✝³ : TopologicalSpace β
inst✝² : OrderTopology β
inst✝¹ : Nonempty γ
inst✝ : DenselyOrdered α
a✝ b✝ a b : α
s : Set α
hs : IsClosed (s ∩ Icc a b)
ha : a ∈ s
hgt : ∀ (x : α), x ∈ s ∩ Ico a b → s ∈ 𝓝[Ioi x] x
⊢ ∀ (x : α), x ∈ s ∩ Ico a b → ∀ (y : α), y ∈ Ioi x → Set.Nonempty (s ∩ Ioc x y)

tactic: have : s ∩ Ioc x y ∈ 𝓝[>] x :=
  inter_mem (hgt x ⟨hxs, hxab⟩) (Ioc_mem_nhdsWithin_Ioi ⟨le_rfl, hyxb⟩)
state_before: case intro
α : Type u
β : Type v
γ : Type w
inst✝⁷ : ConditionallyCompleteLinearOrder α
inst✝⁶ : TopologicalSpace α
inst✝⁵ : OrderTopology α
inst✝⁴ : ConditionallyCompleteLinearOrder β
inst✝³ : TopologicalSpace β
inst✝² : OrderTopology β
inst✝¹ : Nonempty γ
inst✝ : DenselyOrdered α
a✝ b✝ a b : α
s : Set α
hs : IsClosed (s ∩ Icc a b)
ha : a ∈ s
hgt : ∀ (x : α), x ∈ s ∩ Ico a b → s ∈ 𝓝[Ioi x] x
x : α
hxs : x ∈ s
hxab : x ∈ Ico a b
y : α
hyxb : y ∈ Ioi x
⊢ Set.Nonempty (s ∩ Ioc x y)

tactic: exact (nhdsWithin_Ioi_self_neBot' ⟨b, hxab.2⟩).nonempty_of_mem this
state_before: case intro
α : Type u
β : Type v
γ : Type w
inst✝⁷ : ConditionallyCompleteLinearOrder α
inst✝⁶ : TopologicalSpace α
inst✝⁵ : OrderTopology α
inst✝⁴ : ConditionallyCompleteLinearOrder β
inst✝³ : TopologicalSpace β
inst✝² : OrderTopology β
inst✝¹ : Nonempty γ
inst✝ : DenselyOrdered α
a✝ b✝ a b : α
s : Set α
hs : IsClosed (s ∩ Icc a b)
ha : a ∈ s
hgt : ∀ (x : α), x ∈ s ∩ Ico a b → s ∈ 𝓝[Ioi x] x
x : α
hxs : x ∈ s
hxab : x ∈ Ico a b
y : α
hyxb : y ∈ Ioi x
this : s ∩ Ioc x y ∈ 𝓝[Ioi x] x
⊢ Set.Nonempty (s ∩ Ioc x y)
Theorem: aestronglyMeasurable_const_smul_iff
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

tactic: simpa only [inv_smul_smul] using h.const_smul' c⁻¹
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.417786
ι : Type ?u.417789
inst✝¹¹ : Countable ι
m : MeasurableSpace α
μ : Measure α
inst✝¹⁰ : TopologicalSpace β
inst✝⁹ : TopologicalSpace γ
f g : α → β
M : Type ?u.417820
G : Type u_3
G₀ : Type ?u.417826
inst✝⁸ : Monoid M
inst✝⁷ : MulAction M β
inst✝⁶ : ContinuousConstSMul M β
inst✝⁵ : Group G
inst✝⁴ : MulAction G β
inst✝³ : ContinuousConstSMul G β
inst✝² : GroupWithZero G₀
inst✝¹ : MulAction G₀ β
inst✝ : ContinuousConstSMul G₀ β
c : G
h : AEStronglyMeasurable (fun x => c • f x) μ
⊢ AEStronglyMeasurable f μ
Theorem: MeasureTheory.setToFun_sub
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: rw [sub_eq_add_neg, sub_eq_add_neg, setToFun_add hT hf hg.neg, setToFun_neg hT g]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1464610
G : Type ?u.1464613
𝕜 : Type ?u.1464616
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f g : α → E
hT : DominatedFinMeasAdditive μ T C
hf : Integrable f
hg : Integrable g
⊢ setToFun μ T hT (f - g) = setToFun μ T hT f - setToFun μ T hT g
Theorem: List.take_sum_join
File: Mathlib/Data/List/Join.lean

tactic: induction L generalizing i
state_before: α : Type u_1
β : Type ?u.5739
L : List (List α)
i : ℕ
⊢ take (sum (take i (map length L))) (join L) = join (take i L)

tactic: simp
state_before: case nil
α : Type u_1
β : Type ?u.5739
i : ℕ
⊢ take (sum (take i (map length []))) (join []) = join (take i [])

tactic: cases i <;> simp [take_append, *]
state_before: case cons
α : Type u_1
β : Type ?u.5739
head✝ : List α
tail✝ : List (List α)
tail_ih✝ : ∀ (i : ℕ), take (sum (take i (map length tail✝))) (join tail✝) = join (take i tail✝)
i : ℕ
⊢ take (sum (take i (map length (head✝ :: tail✝)))) (join (head✝ :: tail✝)) = join (take i (head✝ :: tail✝))
Theorem: biSup_inf_biSup
File: Mathlib/Order/CompleteBooleanAlgebra.lean

tactic: simp only [iSup_subtype', iSup_inf_iSup]
state_before: α : Type u
β : Type v
ι✝ : Sort w
κ : ι✝ → Sort ?u.5320
inst✝ : Frame α
s✝ t✝ : Set α
a b : α
ι : Type u_1
ι' : Type u_2
f : ι → α
g : ι' → α
s : Set ι
t : Set ι'
⊢ ((⨆ (i : ι) (_ : i ∈ s), f i) ⊓ ⨆ (j : ι') (_ : j ∈ t), g j) = ⨆ (p : ι × ι') (_ : p ∈ s ×ˢ t), f p.fst ⊓ g p.snd

tactic: exact (Equiv.surjective _).iSup_congr (Equiv.Set.prod s t).symm fun x => rfl
state_before: α : Type u
β : Type v
ι✝ : Sort w
κ : ι✝ → Sort ?u.5320
inst✝ : Frame α
s✝ t✝ : Set α
a b : α
ι : Type u_1
ι' : Type u_2
f : ι → α
g : ι' → α
s : Set ι
t : Set ι'
⊢ (⨆ (i : { i // i ∈ s } × { i // i ∈ t }), f ↑i.fst ⊓ g ↑i.snd) = ⨆ (x : { i // i ∈ s ×ˢ t }), f (↑x).fst ⊓ g (↑x).snd
Theorem: ProbabilityTheory.cond_cond_eq_cond_inter'
File: Mathlib/Probability/ConditionalProbability.lean

tactic: have hcs' : μ s ≠ 0 :=
  (μ.toOuterMeasure.pos_of_subset_ne_zero (Set.inter_subset_left _ _) hci).ne'
state_before: Ω : Type u_1
m : MeasurableSpace Ω
μ : MeasureTheory.Measure Ω
s t : Set Ω
hms : MeasurableSet s
hmt : MeasurableSet t
hcs : ↑↑μ s ≠ ⊤
hci : ↑↑μ (s ∩ t) ≠ 0
⊢ μ[|s][|t] = μ[|s ∩ t]

tactic: ext u
state_before: Ω : Type u_1
m : MeasurableSpace Ω
μ : MeasureTheory.Measure Ω
s t : Set Ω
hms : MeasurableSet s
hmt : MeasurableSet t
hcs : ↑↑μ s ≠ ⊤
hci : ↑↑μ (s ∩ t) ≠ 0
hcs' : ↑↑μ s ≠ 0
⊢ μ[|s][|t] = μ[|s ∩ t]

tactic: intro
state_before: case h
Ω : Type u_1
m : MeasurableSpace Ω
μ : MeasureTheory.Measure Ω
s t : Set Ω
hms : MeasurableSet s
hmt : MeasurableSet t
hcs : ↑↑μ s ≠ ⊤
hci : ↑↑μ (s ∩ t) ≠ 0
hcs' : ↑↑μ s ≠ 0
u : Set Ω
⊢ MeasurableSet u → ↑↑(μ[|s][|t]) u = ↑↑(μ[|s ∩ t]) u

tactic: simp [*, hms.inter hmt, cond_apply, ← mul_assoc, ← Set.inter_assoc, ENNReal.mul_inv, mul_comm, ←
  mul_assoc, ENNReal.mul_inv_cancel]
state_before: case h
Ω : Type u_1
m : MeasurableSpace Ω
μ : MeasureTheory.Measure Ω
s t : Set Ω
hms : MeasurableSet s
hmt : MeasurableSet t
hcs : ↑↑μ s ≠ ⊤
hci : ↑↑μ (s ∩ t) ≠ 0
hcs' : ↑↑μ s ≠ 0
u : Set Ω
a✝ : MeasurableSet u
⊢ ↑↑(μ[|s][|t]) u = ↑↑(μ[|s ∩ t]) u
Theorem: Equiv.Perm.signAux3_symm_trans_trans
File: Mathlib/GroupTheory/Perm/Sign.lean

tactic: induction' t, s using Quotient.inductionOn₂ with t s ht hs
state_before: α : Type u
β : Type v
inst✝³ : DecidableEq α
inst✝² : Fintype α
inst✝¹ : DecidableEq β
inst✝ : Fintype β
f : Perm α
e : α ≃ β
s : Multiset α
t : Multiset β
hs : ∀ (x : α), x ∈ s
ht : ∀ (x : β), x ∈ t
⊢ signAux3 ((e.symm.trans f).trans e) ht = signAux3 f hs

tactic: show signAux2 _ _ = signAux2 _ _
state_before: case h
α : Type u
β : Type v
inst✝³ : DecidableEq α
inst✝² : Fintype α
inst✝¹ : DecidableEq β
inst✝ : Fintype β
f : Perm α
e : α ≃ β
s✝ : Multiset α
t✝ : Multiset β
hs✝ : ∀ (x : α), x ∈ s✝
ht✝ : ∀ (x : β), x ∈ t✝
t : List β
s : List α
hs : ∀ (x : α), x ∈ Quotient.mk (List.isSetoid α) s
ht : ∀ (x : β), x ∈ Quotient.mk (List.isSetoid β) t
⊢ signAux3 ((e.symm.trans f).trans e) ht = signAux3 f hs

tactic: let n := equivFin β
state_before: case h
α : Type u
β : Type v
inst✝³ : DecidableEq α
inst✝² : Fintype α
inst✝¹ : DecidableEq β
inst✝ : Fintype β
f : Perm α
e : α ≃ β
s✝ : Multiset α
t✝ : Multiset β
hs✝ : ∀ (x : α), x ∈ s✝
ht✝ : ∀ (x : β), x ∈ t✝
t : List β
s : List α
hs : ∀ (x : α), x ∈ Quotient.mk (List.isSetoid α) s
ht : ∀ (x : β), x ∈ Quotient.mk (List.isSetoid β) t
⊢ signAux2 t ((e.symm.trans f).trans e) = signAux2 s f

tactic: rw [← signAux_eq_signAux2 _ _ n fun _ _ => ht _,
  ← signAux_eq_signAux2 _ _ (e.trans n) fun _ _ => hs _]
state_before: case h
α : Type u
β : Type v
inst✝³ : DecidableEq α
inst✝² : Fintype α
inst✝¹ : DecidableEq β
inst✝ : Fintype β
f : Perm α
e : α ≃ β
s✝ : Multiset α
t✝ : Multiset β
hs✝ : ∀ (x : α), x ∈ s✝
ht✝ : ∀ (x : β), x ∈ t✝
t : List β
s : List α
hs : ∀ (x : α), x ∈ Quotient.mk (List.isSetoid α) s
ht : ∀ (x : β), x ∈ Quotient.mk (List.isSetoid β) t
n : β ≃ Fin (Fintype.card β) := Fintype.equivFin β
⊢ signAux2 t ((e.symm.trans f).trans e) = signAux2 s f

tactic: exact congr_arg signAux
  (Equiv.ext fun x => by simp [Equiv.coe_trans, apply_eq_iff_eq, symm_trans_apply])
state_before: case h
α : Type u
β : Type v
inst✝³ : DecidableEq α
inst✝² : Fintype α
inst✝¹ : DecidableEq β
inst✝ : Fintype β
f : Perm α
e : α ≃ β
s✝ : Multiset α
t✝ : Multiset β
hs✝ : ∀ (x : α), x ∈ s✝
ht✝ : ∀ (x : β), x ∈ t✝
t : List β
s : List α
hs : ∀ (x : α), x ∈ Quotient.mk (List.isSetoid α) s
ht : ∀ (x : β), x ∈ Quotient.mk (List.isSetoid β) t
n : β ≃ Fin (Fintype.card β) := Fintype.equivFin β
⊢ signAux ((n.symm.trans ((e.symm.trans f).trans e)).trans n) = signAux (((e.trans n).symm.trans f).trans (e.trans n))

tactic: simp [Equiv.coe_trans, apply_eq_iff_eq, symm_trans_apply]
state_before: α : Type u
β : Type v
inst✝³ : DecidableEq α
inst✝² : Fintype α
inst✝¹ : DecidableEq β
inst✝ : Fintype β
f : Perm α
e : α ≃ β
s✝ : Multiset α
t✝ : Multiset β
hs✝ : ∀ (x : α), x ∈ s✝
ht✝ : ∀ (x : β), x ∈ t✝
t : List β
s : List α
hs : ∀ (x : α), x ∈ Quotient.mk (List.isSetoid α) s
ht : ∀ (x : β), x ∈ Quotient.mk (List.isSetoid β) t
n : β ≃ Fin (Fintype.card β) := Fintype.equivFin β
x : Fin (Fintype.card β)
⊢ ↑((n.symm.trans ((e.symm.trans f).trans e)).trans n) x = ↑(((e.trans n).symm.trans f).trans (e.trans n)) x
Theorem: ContinuousMultilinearMap.unit_le_op_norm
File: Mathlib/Analysis/NormedSpace/Multilinear.lean

tactic: simp
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin (Nat.succ n) → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁴ : Fintype ι
inst✝¹³ : Fintype ι'
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁷ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁶ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁵ : (i : Fin (Nat.succ n)) → NormedAddCommGroup (Ei i)
inst✝⁴ : (i : Fin (Nat.succ n)) → NormedSpace 𝕜 (Ei i)
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
c : 𝕜
f g : ContinuousMultilinearMap 𝕜 E G
m : (i : ι) → E i
h : ‖m‖ ≤ 1
⊢ ‖f‖ * ∏ i : ι, 1 = ‖f‖
Theorem: Metric.Bounded.exists_pos_norm_le'
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: positivity
state_before: 𝓕 : Type ?u.99872
𝕜 : Type ?u.99875
α : Type ?u.99878
ι : Type ?u.99881
κ : Type ?u.99884
E : Type u_1
F : Type ?u.99890
G : Type ?u.99893
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
hs : Bounded s
R₀ : ℝ
hR₀ : ∀ (x : E), x ∈ s → ‖x‖ ≤ R₀
⊢ max R₀ 1 > 0
Theorem: ENNReal.toNNReal_rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: rcases lt_trichotomy z 0 with (H | H | H)
state_before: x : ℝ≥0∞
z : ℝ
⊢ ENNReal.toNNReal x ^ z = ENNReal.toNNReal (x ^ z)

tactic: cases' x with x
state_before: case inl
x : ℝ≥0∞
z : ℝ
H : z < 0
⊢ ENNReal.toNNReal x ^ z = ENNReal.toNNReal (x ^ z)

tactic: by_cases hx : x = 0
state_before: case inl.some
z : ℝ
H : z < 0
x : ℝ≥0
⊢ ENNReal.toNNReal (Option.some x) ^ z = ENNReal.toNNReal (Option.some x ^ z)

tactic: simp [H, ne_of_lt]
state_before: case inl.none
z : ℝ
H : z < 0
⊢ ENNReal.toNNReal none ^ z = ENNReal.toNNReal (none ^ z)

tactic: simp [hx, H, ne_of_lt]
state_before: case pos
z : ℝ
H : z < 0
x : ℝ≥0
hx : x = 0
⊢ ENNReal.toNNReal (Option.some x) ^ z = ENNReal.toNNReal (Option.some x ^ z)

tactic: simp [coe_rpow_of_ne_zero hx]
state_before: case neg
z : ℝ
H : z < 0
x : ℝ≥0
hx : ¬x = 0
⊢ ENNReal.toNNReal (Option.some x) ^ z = ENNReal.toNNReal (Option.some x ^ z)

tactic: simp [H]
state_before: case inr.inl
x : ℝ≥0∞
z : ℝ
H : z = 0
⊢ ENNReal.toNNReal x ^ z = ENNReal.toNNReal (x ^ z)

tactic: cases x
state_before: case inr.inr
x : ℝ≥0∞
z : ℝ
H : 0 < z
⊢ ENNReal.toNNReal x ^ z = ENNReal.toNNReal (x ^ z)

tactic: simp [coe_rpow_of_nonneg _ (le_of_lt H)]
state_before: case inr.inr.some
z : ℝ
H : 0 < z
val✝ : ℝ≥0
⊢ ENNReal.toNNReal (Option.some val✝) ^ z = ENNReal.toNNReal (Option.some val✝ ^ z)

tactic: simp [H, ne_of_gt]
state_before: case inr.inr.none
z : ℝ
H : 0 < z
⊢ ENNReal.toNNReal none ^ z = ENNReal.toNNReal (none ^ z)
Theorem: List.sublists'Aux_eq_map
File: Mathlib/Data/List/Sublists.lean

tactic: simp [sublists'Aux]
state_before: α : Type u
β : Type v
γ : Type w
a : α
r₁ x✝ : List (List α)
⊢ sublists'Aux a [] x✝ = x✝ ++ map (cons a) []

tactic: rw [map_append, map_singleton, ← append_assoc, ← ih, sublists'Aux, foldl_append, foldl]
state_before: α : Type u
β : Type v
γ : Type w
a : α
r₁✝ r₁ : List (List α)
l : List α
ih : ∀ (r₂ : List (List α)), sublists'Aux a r₁ r₂ = r₂ ++ map (cons a) r₁
r₂ : List (List α)
⊢ sublists'Aux a (r₁ ++ [l]) r₂ = r₂ ++ map (cons a) (r₁ ++ [l])

tactic: simp [sublists'Aux]
state_before: α : Type u
β : Type v
γ : Type w
a : α
r₁✝ r₁ : List (List α)
l : List α
ih : ∀ (r₂ : List (List α)), sublists'Aux a r₁ r₂ = r₂ ++ map (cons a) r₁
r₂ : List (List α)
⊢ foldl (fun r l => r ++ [a :: l]) (foldl (fun r l => r ++ [a :: l]) r₂ r₁ ++ [a :: l]) [] =
    sublists'Aux a r₁ r₂ ++ [a :: l]
Theorem: AlgebraicTopology.DoldKan.PInftyToNormalizedMooreComplex_naturality
File: Mathlib/AlgebraicTopology/DoldKan/Normalized.lean

tactic: aesop_cat
state_before: A : Type u_2
inst✝¹ : Category A
inst✝ : Abelian A
X✝ X Y : SimplicialObject A
f : X ⟶ Y
⊢ AlternatingFaceMapComplex.map f ≫ PInftyToNormalizedMooreComplex Y =
    PInftyToNormalizedMooreComplex X ≫ NormalizedMooreComplex.map f
Theorem: Ordinal.brange_bfamilyOfFamily'
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: refine' Set.ext fun a => ⟨_, _⟩
state_before: α : Type u_1
β : Type ?u.276348
γ : Type ?u.276351
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u
r : ι → ι → Prop
inst✝ : IsWellOrder ι r
f : ι → α
⊢ brange (type r) (bfamilyOfFamily' r f) = range f

tactic: rintro ⟨i, hi, rfl⟩
state_before: case refine'_1
α : Type u_1
β : Type ?u.276348
γ : Type ?u.276351
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u
r : ι → ι → Prop
inst✝ : IsWellOrder ι r
f : ι → α
a : α
⊢ a ∈ brange (type r) (bfamilyOfFamily' r f) → a ∈ range f

tactic: apply mem_range_self
state_before: case refine'_1.intro.intro
α : Type u_1
β : Type ?u.276348
γ : Type ?u.276351
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u
r : ι → ι → Prop
inst✝ : IsWellOrder ι r
f : ι → α
i : Ordinal
hi : i < type r
⊢ bfamilyOfFamily' r f i hi ∈ range f

tactic: rintro ⟨b, rfl⟩
state_before: case refine'_2
α : Type u_1
β : Type ?u.276348
γ : Type ?u.276351
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u
r : ι → ι → Prop
inst✝ : IsWellOrder ι r
f : ι → α
a : α
⊢ a ∈ range f → a ∈ brange (type r) (bfamilyOfFamily' r f)

tactic: exact ⟨_, _, bfamilyOfFamily'_typein _ _ _⟩
state_before: case refine'_2.intro
α : Type u_1
β : Type ?u.276348
γ : Type ?u.276351
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u
r : ι → ι → Prop
inst✝ : IsWellOrder ι r
f : ι → α
b : ι
⊢ f b ∈ brange (type r) (bfamilyOfFamily' r f)
Theorem: CategoryTheory.MonoidalCategory.prodMonoidal_rightUnitor_inv_snd
File: Mathlib/CategoryTheory/Monoidal/Category.lean

tactic: cases X
state_before: C : Type u
𝒞 : Category C
inst✝⁴ : MonoidalCategory C
C₁ : Type u₁
inst✝³ : Category C₁
inst✝² : MonoidalCategory C₁
C₂ : Type u₂
inst✝¹ : Category C₂
inst✝ : MonoidalCategory C₂
X : C₁ × C₂
⊢ (ρ_ X).inv.snd = (ρ_ X.snd).inv

tactic: rfl
state_before: case mk
C : Type u
𝒞 : Category C
inst✝⁴ : MonoidalCategory C
C₁ : Type u₁
inst✝³ : Category C₁
inst✝² : MonoidalCategory C₁
C₂ : Type u₂
inst✝¹ : Category C₂
inst✝ : MonoidalCategory C₂
fst✝ : C₁
snd✝ : C₂
⊢ (ρ_ (fst✝, snd✝)).inv.snd = (ρ_ (fst✝, snd✝).snd).inv
Theorem: Polynomial.revAtFun_inj
File: Mathlib/Data/Polynomial/Reverse.lean

tactic: intro a b hab
state_before: R : Type ?u.1604
inst✝ : Semiring R
f : R[X]
N : ℕ
⊢ Function.Injective (revAtFun N)

tactic: rw [← @revAtFun_invol N a, hab, revAtFun_invol]
state_before: R : Type ?u.1604
inst✝ : Semiring R
f : R[X]
N a b : ℕ
hab : revAtFun N a = revAtFun N b
⊢ a = b
Theorem: Real.nnnorm_mul_toNNReal
File: Mathlib/Analysis/Normed/Field/Basic.lean

tactic: rw [mul_comm, mul_comm x, toNNReal_mul_nnnorm x hy]
state_before: α : Type ?u.381722
β : Type ?u.381725
γ : Type ?u.381728
ι : Type ?u.381731
x y : ℝ
hy : 0 ≤ y
⊢ ‖x‖₊ * toNNReal y = ‖x * y‖₊
Theorem: AffineMap.linearMap_vsub
File: Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean

tactic: conv_rhs => rw [← vsub_vadd p1 p2, map_vadd, vadd_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.43498
P3 : Type ?u.43501
V4 : Type ?u.43504
P4 : Type ?u.43507
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
p1 p2 : P1
⊢ ↑f.linear (p1 -ᵥ p2) = ↑f p1 -ᵥ ↑f p2