tasksource/leandojo huggingface dataset:
Theorem: Equiv.Perm.Disjoint.disjoint_cycleFactorsFinset
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: rw [disjoint_iff_disjoint_support] at h
state_before: ι : Type ?u.2757665
α : Type u_1
β : Type ?u.2757671
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ f g : Perm α
h : Disjoint f g
⊢ _root_.Disjoint (cycleFactorsFinset f) (cycleFactorsFinset g)

tactic: rw [Finset.disjoint_left]
state_before: ι : Type ?u.2757665
α : Type u_1
β : Type ?u.2757671
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ f g : Perm α
h✝ : Disjoint f g
h : _root_.Disjoint (support f) (support g)
⊢ _root_.Disjoint (cycleFactorsFinset f) (cycleFactorsFinset g)

tactic: intro x hx hy
state_before: ι : Type ?u.2757665
α : Type u_1
β : Type ?u.2757671
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ f g : Perm α
h✝ : Disjoint f g
h : _root_.Disjoint (support f) (support g)
⊢ ∀ ⦃a : Perm α⦄, a ∈ cycleFactorsFinset f → ¬a ∈ cycleFactorsFinset g

tactic: simp only [mem_cycleFactorsFinset_iff, mem_support] at hx hy
state_before: ι : Type ?u.2757665
α : Type u_1
β : Type ?u.2757671
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ f g : Perm α
h✝ : Disjoint f g
h : _root_.Disjoint (support f) (support g)
x : Perm α
hx : x ∈ cycleFactorsFinset f
hy : x ∈ cycleFactorsFinset g
⊢ False

tactic: obtain ⟨⟨⟨a, ha, -⟩, hf⟩, -, hg⟩ := hx, hy
state_before: ι : Type ?u.2757665
α : Type u_1
β : Type ?u.2757671
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ f g : Perm α
h✝ : Disjoint f g
h : _root_.Disjoint (support f) (support g)
x : Perm α
hx : IsCycle x ∧ ∀ (a : α), ↑x a ≠ a → ↑x a = ↑f a
hy : IsCycle x ∧ ∀ (a : α), ↑x a ≠ a → ↑x a = ↑g a
⊢ False

tactic: have := h.le_bot (by simp [ha, ← hf a ha, ← hg a ha] : a ∈ f.support ∩ g.support)
state_before: case intro.intro.intro.intro
ι : Type ?u.2757665
α : Type u_1
β : Type ?u.2757671
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ f g : Perm α
h✝ : Disjoint f g
h : _root_.Disjoint (support f) (support g)
x : Perm α
hf : ∀ (a : α), ↑x a ≠ a → ↑x a = ↑f a
a : α
ha : ↑x a ≠ a
hg : ∀ (a : α), ↑x a ≠ a → ↑x a = ↑g a
⊢ False

tactic: tauto
state_before: case intro.intro.intro.intro
ι : Type ?u.2757665
α : Type u_1
β : Type ?u.2757671
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ f g : Perm α
h✝ : Disjoint f g
h : _root_.Disjoint (support f) (support g)
x : Perm α
hf : ∀ (a : α), ↑x a ≠ a → ↑x a = ↑f a
a : α
ha : ↑x a ≠ a
hg : ∀ (a : α), ↑x a ≠ a → ↑x a = ↑g a
this : a ∈ ⊥
⊢ False

tactic: simp [ha, ← hf a ha, ← hg a ha]
state_before: ι : Type ?u.2757665
α : Type u_1
β : Type ?u.2757671
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ f g : Perm α
h✝ : Disjoint f g
h : _root_.Disjoint (support f) (support g)
x : Perm α
hf : ∀ (a : α), ↑x a ≠ a → ↑x a = ↑f a
a : α
ha : ↑x a ≠ a
hg : ∀ (a : α), ↑x a ≠ a → ↑x a = ↑g a
⊢ a ∈ support f ∩ support g
Theorem: Nat.one_lt_bit0
File: Mathlib/Init/Data/Nat/Lemmas.lean

tactic: contradiction
state_before: h : 0 ≠ 0
⊢ 1 < bit0 0

tactic: rw [Nat.bit0_succ_eq]
state_before: n : ℕ
x✝ : succ n ≠ 0
⊢ 1 < bit0 (succ n)

tactic: apply succ_lt_succ
state_before: n : ℕ
x✝ : succ n ≠ 0
⊢ 1 < succ (succ (bit0 n))

tactic: apply zero_lt_succ
state_before: case a
n : ℕ
x✝ : succ n ≠ 0
⊢ 0 < bit0 n + 1
Theorem: all_mem_nhds
File: Mathlib/Topology/Basic.lean

tactic: simp only [@and_comm (x ∈ _), and_imp]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
x : α
P : Set α → Prop
hP : ∀ (s t : Set α), s ⊆ t → P s → P t
⊢ (∀ (i : Set α), x ∈ i ∧ IsOpen i → P i) ↔ ∀ (s : Set α), IsOpen s → x ∈ s → P s
Theorem: MvPowerSeries.monomial_def
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: rw [monomial]
state_before: σ : Type u_1
R : Type u_2
inst✝¹ : Semiring R
inst✝ : DecidableEq σ
n : σ →₀ ℕ
⊢ monomial R n = LinearMap.stdBasis R (fun x => R) n

tactic: convert rfl
state_before: σ : Type u_1
R : Type u_2
inst✝¹ : Semiring R
inst✝ : DecidableEq σ
n : σ →₀ ℕ
⊢ LinearMap.stdBasis R (fun x => R) n = LinearMap.stdBasis R (fun x => R) n
Theorem: Order.succ_eq_succ_iff_of_not_isMax
File: Mathlib/Order/SuccPred/Basic.lean

tactic: rw [eq_iff_le_not_lt, eq_iff_le_not_lt, succ_le_succ_iff_of_not_isMax ha hb,
  succ_lt_succ_iff_of_not_isMax ha hb]
state_before: α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b : α
ha : ¬IsMax a
hb : ¬IsMax b
⊢ succ a = succ b ↔ a = b
Theorem: RingQuot.add_quot
File: Mathlib/Algebra/RingQuot.lean

tactic: show add r _ _ = _
state_before: R : Type u₁
inst✝³ : Semiring R
S : Type u₂
inst✝² : CommSemiring S
A : Type u₃
inst✝¹ : Semiring A
inst✝ : Algebra S A
r : R → R → Prop
a b : R
⊢ { toQuot := Quot.mk (Rel r) a } + { toQuot := Quot.mk (Rel r) b } = { toQuot := Quot.mk (Rel r) (a + b) }

tactic: rw [add_def]
state_before: R : Type u₁
inst✝³ : Semiring R
S : Type u₂
inst✝² : CommSemiring S
A : Type u₃
inst✝¹ : Semiring A
inst✝ : Algebra S A
r : R → R → Prop
a b : R
⊢ RingQuot.add r { toQuot := Quot.mk (Rel r) a } { toQuot := Quot.mk (Rel r) b } = { toQuot := Quot.mk (Rel r) (a + b) }

tactic: rfl
state_before: R : Type u₁
inst✝³ : Semiring R
S : Type u₂
inst✝² : CommSemiring S
A : Type u₃
inst✝¹ : Semiring A
inst✝ : Algebra S A
r : R → R → Prop
a b : R
⊢ (match { toQuot := Quot.mk (Rel r) a }, { toQuot := Quot.mk (Rel r) b } with
    | { toQuot := a }, { toQuot := b } =>
      {
        toQuot :=
          Quot.map₂ (fun x x_1 => x + x_1) (_ : ∀ ⦃a b c : R⦄, Rel r b c → Rel r (a + b) (a + c))
            (_ : ∀ ⦃a b c : R⦄, Rel r a b → Rel r (a + c) (b + c)) a b }) =
    { toQuot := Quot.mk (Rel r) (a + b) }
Theorem: SimplexCategory.len_le_of_epi
File: Mathlib/AlgebraicTopology/SimplexCategory.lean

tactic: intro hyp_f_epi
state_before: x y : SimplexCategory
f : x ⟶ y
⊢ Epi f → len y ≤ len x

tactic: have f_surj : Function.Surjective f.toOrderHom.toFun := epi_iff_surjective.1 hyp_f_epi
state_before: x y : SimplexCategory
f : x ⟶ y
hyp_f_epi : Epi f
⊢ len y ≤ len x

tactic: simpa using Fintype.card_le_of_surjective f.toOrderHom.toFun f_surj
state_before: x y : SimplexCategory
f : x ⟶ y
hyp_f_epi : Epi f
f_surj : Function.Surjective ↑(Hom.toOrderHom f)
⊢ len y ≤ len x
Theorem: CauSeq.equiv_def₃
File: Mathlib/Data/Real/CauSeq.lean

tactic: let ⟨h₁, h₂⟩ := H _ ij
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f g : CauSeq β abv
h : f ≈ g
ε : α
ε0 : 0 < ε
i : ℕ
H : ∀ (j : ℕ), j ≥ i → abv (↑(f - g) j) < ε / 2 ∧ ∀ (k : ℕ), k ≥ j → abv (↑f k - ↑f j) < ε / 2
j : ℕ
ij : j ≥ i
k : ℕ
jk : k ≥ j
⊢ abv (↑f k - ↑g j) < ε

tactic: have := lt_of_le_of_lt (abv_add abv (f j - g j) _) (add_lt_add h₁ (h₂ _ jk))
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f g : CauSeq β abv
h : f ≈ g
ε : α
ε0 : 0 < ε
i : ℕ
H : ∀ (j : ℕ), j ≥ i → abv (↑(f - g) j) < ε / 2 ∧ ∀ (k : ℕ), k ≥ j → abv (↑f k - ↑f j) < ε / 2
j : ℕ
ij : j ≥ i
k : ℕ
jk : k ≥ j
h₁ : abv (↑(f - g) j) < ε / 2
h₂ : ∀ (k : ℕ), k ≥ j → abv (↑f k - ↑f j) < ε / 2
⊢ abv (↑f k - ↑g j) < ε

tactic: rwa [sub_add_sub_cancel', add_halves] at this
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f g : CauSeq β abv
h : f ≈ g
ε : α
ε0 : 0 < ε
i : ℕ
H : ∀ (j : ℕ), j ≥ i → abv (↑(f - g) j) < ε / 2 ∧ ∀ (k : ℕ), k ≥ j → abv (↑f k - ↑f j) < ε / 2
j : ℕ
ij : j ≥ i
k : ℕ
jk : k ≥ j
h₁ : abv (↑(f - g) j) < ε / 2
h₂ : ∀ (k : ℕ), k ≥ j → abv (↑f k - ↑f j) < ε / 2
this : abv (↑f j - ↑g j + (↑f k - ↑f j)) < ε / 2 + ε / 2
⊢ abv (↑f k - ↑g j) < ε
Theorem: exists_mem_nhds_isClosed_subset
File: Mathlib/Topology/Separation.lean

tactic: have h' := (regularSpace_TFAE α).out 0 3
state_before: α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : RegularSpace α
a✝ : α
s✝ : Set α
a : α
s : Set α
h : s ∈ 𝓝 a
⊢ ∃ t, t ∈ 𝓝 a ∧ IsClosed t ∧ t ⊆ s

tactic: exact h'.mp ‹_› _ _ h
state_before: α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : RegularSpace α
a✝ : α
s✝ : Set α
a : α
s : Set α
h : s ∈ 𝓝 a
h' : RegularSpace α ↔ ∀ (a : α) (s : Set α), s ∈ 𝓝 a → ∃ t, t ∈ 𝓝 a ∧ IsClosed t ∧ t ⊆ s
⊢ ∃ t, t ∈ 𝓝 a ∧ IsClosed t ∧ t ⊆ s
Theorem: MeasureTheory.set_integral_eq_subtype
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: rw [← map_comap_subtype_coe hs]
state_before: α✝ : Type ?u.1476210
E : Type u_2
F : Type ?u.1476216
𝕜 : Type ?u.1476219
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace ℝ E
inst✝⁹ : CompleteSpace E
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : SMulCommClass ℝ 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : CompleteSpace F
f✝ g : α✝ → E
m : MeasurableSpace α✝
μ : Measure α✝
X : Type ?u.1478910
inst✝² : TopologicalSpace X
inst✝¹ : FirstCountableTopology X
ν : Measure α✝
α : Type u_1
inst✝ : MeasureSpace α
s : Set α
hs : MeasurableSet s
f : α → E
⊢ (∫ (x : α) in s, f x) = ∫ (x : ↑s), f ↑x

tactic: exact (MeasurableEmbedding.subtype_coe hs).integral_map _
state_before: α✝ : Type ?u.1476210
E : Type u_2
F : Type ?u.1476216
𝕜 : Type ?u.1476219
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace ℝ E
inst✝⁹ : CompleteSpace E
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : SMulCommClass ℝ 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : CompleteSpace F
f✝ g : α✝ → E
m : MeasurableSpace α✝
μ : Measure α✝
X : Type ?u.1478910
inst✝² : TopologicalSpace X
inst✝¹ : FirstCountableTopology X
ν : Measure α✝
α : Type u_1
inst✝ : MeasureSpace α
s : Set α
hs : MeasurableSet s
f : α → E
⊢ (∫ (x : α), f x ∂Measure.map Subtype.val (Measure.comap Subtype.val volume)) = ∫ (x : ↑s), f ↑x
Theorem: Finsupp.prod_embDomain
File: Mathlib/Algebra/BigOperators/Finsupp.lean

tactic: rw [prod, prod, support_embDomain, Finset.prod_map]
state_before: α : Type u_3
ι : Type ?u.531151
γ : Type ?u.531154
A : Type ?u.531157
B : Type ?u.531160
C : Type ?u.531163
inst✝⁴ : AddCommMonoid A
inst✝³ : AddCommMonoid B
inst✝² : AddCommMonoid C
t : ι → A → C
h0 : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s : Finset α
f✝ : α → ι →₀ A
i : ι
g✝ : ι →₀ A
k : ι → A → γ → B
x : γ
β : Type u_4
M : Type u_1
M' : Type ?u.534299
N : Type u_2
P : Type ?u.534305
G : Type ?u.534308
H : Type ?u.534311
R : Type ?u.534314
S : Type ?u.534317
inst✝¹ : Zero M
inst✝ : CommMonoid N
v : α →₀ M
f : α ↪ β
g : β → M → N
⊢ prod (embDomain f v) g = prod v fun a b => g (↑f a) b

tactic: simp_rw [embDomain_apply]
state_before: α : Type u_3
ι : Type ?u.531151
γ : Type ?u.531154
A : Type ?u.531157
B : Type ?u.531160
C : Type ?u.531163
inst✝⁴ : AddCommMonoid A
inst✝³ : AddCommMonoid B
inst✝² : AddCommMonoid C
t : ι → A → C
h0 : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s : Finset α
f✝ : α → ι →₀ A
i : ι
g✝ : ι →₀ A
k : ι → A → γ → B
x : γ
β : Type u_4
M : Type u_1
M' : Type ?u.534299
N : Type u_2
P : Type ?u.534305
G : Type ?u.534308
H : Type ?u.534311
R : Type ?u.534314
S : Type ?u.534317
inst✝¹ : Zero M
inst✝ : CommMonoid N
v : α →₀ M
f : α ↪ β
g : β → M → N
⊢ ∏ x in v.support, g (↑f x) (↑(embDomain f v) (↑f x)) = ∏ a in v.support, g (↑f a) (↑v a)
Theorem: Bool.true_or
File: src/lean/Init/SimpLemmas.lean

tactic: cases b <;> rfl
state_before: b : Bool
⊢ (true || b) = true
Theorem: Colex.sdiff_le_sdiff_iff_le
File: Mathlib/Combinatorics/Colex.lean

tactic: rw [le_iff_le_iff_lt_iff_lt, sdiff_lt_sdiff_iff_lt]
state_before: α : Type u_1
inst✝ : LinearOrder α
A B : Finset α
⊢ toColex (A \ B) ≤ toColex (B \ A) ↔ toColex A ≤ toColex B
Theorem: inner_smul_real_left
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [inner_smul_left, conj_ofReal, Algebra.smul_def]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1383018
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : E
r : ℝ
⊢ inner (↑r • x) y = r • inner x y

tactic: rfl
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1383018
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : E
r : ℝ
⊢ ↑r * inner x y = ↑(algebraMap ℝ 𝕜) r * inner x y
Theorem: List.Func.get_neg
File: Mathlib/Data/List/Func.lean

tactic: unfold neg
state_before: α : Type u
β : Type v
γ : Type w
inst✝ : AddGroup α
k : ℕ
as : List α
⊢ get k (neg as) = -get k as

tactic: rw [@get_map' α α ⟨0⟩ ⟨0⟩]
state_before: α : Type u
β : Type v
γ : Type w
inst✝ : AddGroup α
k : ℕ
as : List α
⊢ get k (map (fun a => -a) as) = -get k as

tactic: apply neg_zero
state_before: case a
α : Type u
β : Type v
γ : Type w
inst✝ : AddGroup α
k : ℕ
as : List α
⊢ -default = default
Theorem: CauSeq.add_equiv_add
File: Mathlib/Data/Real/CauSeq.lean

tactic: simpa only [← add_sub_add_comm] using add_limZero hf hg
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f1 f2 g1 g2 : CauSeq β abv
hf : f1 ≈ f2
hg : g1 ≈ g2
⊢ f1 + g1 ≈ f2 + g2
Theorem: IsOrderConnected.neg_trans
File: Mathlib/Order/RelClasses.lean

tactic: simp [h₁, h₂]
state_before: α : Type u
β : Type v
r✝ : α → α → Prop
s : β → β → Prop
r : α → α → Prop
inst✝ : IsOrderConnected α r
a b c : α
h₁ : ¬r a b
h₂ : ¬r b c
⊢ ¬(r a b ∨ r b c)
Theorem: UniformSpace.Completion.dist_triangle
File: Mathlib/Topology/MetricSpace/Completion.lean

tactic: refine' induction_on₃ x y z _ _
state_before: α : Type u
β : Type v
inst✝ : PseudoMetricSpace α
x y z : Completion α
⊢ dist x z ≤ dist x y + dist y z

tactic: refine' isClosed_le _ (Continuous.add _ _) <;>
  apply_rules [Completion.continuous_dist, Continuous.fst, Continuous.snd, continuous_id]
state_before: case refine'_1
α : Type u
β : Type v
inst✝ : PseudoMetricSpace α
x y z : Completion α
⊢ IsClosed {x | dist x.fst x.snd.snd ≤ dist x.fst x.snd.fst + dist x.snd.fst x.snd.snd}

tactic: intro a b c
state_before: case refine'_2
α : Type u
β : Type v
inst✝ : PseudoMetricSpace α
x y z : Completion α
⊢ ∀ (a b c : α), dist (↑α a) (↑α c) ≤ dist (↑α a) (↑α b) + dist (↑α b) (↑α c)

tactic: rw [Completion.dist_eq, Completion.dist_eq, Completion.dist_eq]
state_before: case refine'_2
α : Type u
β : Type v
inst✝ : PseudoMetricSpace α
x y z : Completion α
a b c : α
⊢ dist (↑α a) (↑α c) ≤ dist (↑α a) (↑α b) + dist (↑α b) (↑α c)

tactic: exact dist_triangle a b c
state_before: case refine'_2
α : Type u
β : Type v
inst✝ : PseudoMetricSpace α
x y z : Completion α
a b c : α
⊢ dist a c ≤ dist a b + dist b c
Theorem: PNat.div_add_mod'
File: Mathlib/Data/PNat/Basic.lean

tactic: rw [mul_comm]
state_before: m k : ℕ+
⊢ div m k * ↑k + ↑(mod m k) = ↑m

tactic: exact div_add_mod _ _
state_before: m k : ℕ+
⊢ ↑k * div m k + ↑(mod m k) = ↑m
Theorem: Dfinsupp.mk_smul
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: simp only [smul_apply, mk_apply]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝² : Monoid γ
inst✝¹ : (i : ι) → AddMonoid (β i)
inst✝ : (i : ι) → DistribMulAction γ (β i)
s : Finset ι
c : γ
x : (i : ↑↑s) → β ↑i
i : ι
⊢ ↑(mk s (c • x)) i = ↑(c • mk s x) i

tactic: split_ifs <;> [rfl; rw [smul_zero]]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝² : Monoid γ
inst✝¹ : (i : ι) → AddMonoid (β i)
inst✝ : (i : ι) → DistribMulAction γ (β i)
s : Finset ι
c : γ
x : (i : ↑↑s) → β ↑i
i : ι
⊢ (if H : i ∈ s then (c • x) { val := i, property := H } else 0) =
    c • if H : i ∈ s then x { val := i, property := H } else 0
Theorem: Ssyt.col_weak
File: Mathlib/Combinatorics/Young/SemistandardTableau.lean

tactic: cases' eq_or_lt_of_le hi with h h
state_before: μ : YoungDiagram
T : Ssyt μ
i1 i2 j : ℕ
hi : i1 ≤ i2
cell : (i2, j) ∈ μ
⊢ ↑T i1 j ≤ ↑T i2 j

tactic: . rw [h]
state_before: case inl
μ : YoungDiagram
T : Ssyt μ
i1 i2 j : ℕ
hi : i1 ≤ i2
cell : (i2, j) ∈ μ
h : i1 = i2
⊢ ↑T i1 j ≤ ↑T i2 j

case inr
μ : YoungDiagram
T : Ssyt μ
i1 i2 j : ℕ
hi : i1 ≤ i2
cell : (i2, j) ∈ μ
h : i1 < i2
⊢ ↑T i1 j ≤ ↑T i2 j

tactic: . exact le_of_lt (T.col_strict h cell)
state_before: case inr
μ : YoungDiagram
T : Ssyt μ
i1 i2 j : ℕ
hi : i1 ≤ i2
cell : (i2, j) ∈ μ
h : i1 < i2
⊢ ↑T i1 j ≤ ↑T i2 j

tactic: rw [h]
state_before: case inl
μ : YoungDiagram
T : Ssyt μ
i1 i2 j : ℕ
hi : i1 ≤ i2
cell : (i2, j) ∈ μ
h : i1 = i2
⊢ ↑T i1 j ≤ ↑T i2 j

tactic: exact le_of_lt (T.col_strict h cell)
state_before: case inr
μ : YoungDiagram
T : Ssyt μ
i1 i2 j : ℕ
hi : i1 ≤ i2
cell : (i2, j) ∈ μ
h : i1 < i2
⊢ ↑T i1 j ≤ ↑T i2 j
Theorem: Nat.sq_mul_squarefree
File: Mathlib/Data/Nat/Squarefree.lean

tactic: cases' n with n
state_before: n : ℕ
⊢ ∃ a b, b ^ 2 * a = n ∧ Squarefree a

tactic: exact ⟨1, 0, by simp, squarefree_one⟩
state_before: case zero

⊢ ∃ a b, b ^ 2 * a = zero ∧ Squarefree a

tactic: simp
state_before: ⊢ 0 ^ 2 * 1 = zero

tactic: obtain ⟨a, b, -, -, h₁, h₂⟩ := sq_mul_squarefree_of_pos (succ_pos n)
state_before: case succ
n : ℕ
⊢ ∃ a b, b ^ 2 * a = succ n ∧ Squarefree a

tactic: exact ⟨a, b, h₁, h₂⟩
state_before: case succ.intro.intro.intro.intro.intro
n a b : ℕ
h₁ : b ^ 2 * a = succ n
h₂ : Squarefree a
⊢ ∃ a b, b ^ 2 * a = succ n ∧ Squarefree a
Theorem: AffineSubspace.sOppSide_comm
File: Mathlib/Analysis/Convex/Side.lean

tactic: rw [SOppSide, SOppSide, wOppSide_comm, and_comm (b := x ∉ s)]
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.95363
P : Type u_3
P' : Type ?u.95369
inst✝⁶ : StrictOrderedCommRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y : P
⊢ SOppSide s x y ↔ SOppSide s y x
Theorem: mem_uniform_prod
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: rw [uniformity_prod]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.155123
t₁ : UniformSpace α
t₂ : UniformSpace β
a : Set (α × α)
b : Set (β × β)
ha : a ∈ 𝓤 α
hb : b ∈ 𝓤 β
⊢ {p | (p.fst.fst, p.snd.fst) ∈ a ∧ (p.fst.snd, p.snd.snd) ∈ b} ∈ 𝓤 (α × β)

tactic: exact inter_mem_inf (preimage_mem_comap ha) (preimage_mem_comap hb)
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.155123
t₁ : UniformSpace α
t₂ : UniformSpace β
a : Set (α × α)
b : Set (β × β)
ha : a ∈ 𝓤 α
hb : b ∈ 𝓤 β
⊢ {p | (p.fst.fst, p.snd.fst) ∈ a ∧ (p.fst.snd, p.snd.snd) ∈ b} ∈
    comap (fun p => (p.fst.fst, p.snd.fst)) (𝓤 α) ⊓ comap (fun p => (p.fst.snd, p.snd.snd)) (𝓤 β)
Theorem: Multiset.noncommProd_coe
File: Mathlib/Data/Finset/NoncommProd.lean

tactic: rw [noncommProd]
state_before: F : Type ?u.7239
ι : Type ?u.7242
α : Type u_1
β : Type ?u.7248
γ : Type ?u.7251
f : α → β → β
op : α → α → α
inst✝¹ : Monoid α
inst✝ : Monoid β
l : List α
comm : Set.Pairwise {x | x ∈ ↑l} Commute
⊢ noncommProd (↑l) comm = List.prod l

tactic: simp only [noncommFold_coe]
state_before: F : Type ?u.7239
ι : Type ?u.7242
α : Type u_1
β : Type ?u.7248
γ : Type ?u.7251
f : α → β → β
op : α → α → α
inst✝¹ : Monoid α
inst✝ : Monoid β
l : List α
comm : Set.Pairwise {x | x ∈ ↑l} Commute
⊢ noncommFold (fun x x_1 => x * x_1) (↑l) comm 1 = List.prod l

tactic: induction' l with hd tl hl
state_before: F : Type ?u.7239
ι : Type ?u.7242
α : Type u_1
β : Type ?u.7248
γ : Type ?u.7251
f : α → β → β
op : α → α → α
inst✝¹ : Monoid α
inst✝ : Monoid β
l : List α
comm : Set.Pairwise {x | x ∈ ↑l} Commute
⊢ List.foldr (fun x x_1 => x * x_1) 1 l = List.prod l

tactic: simp
state_before: case nil
F : Type ?u.7239
ι : Type ?u.7242
α : Type u_1
β : Type ?u.7248
γ : Type ?u.7251
f : α → β → β
op : α → α → α
inst✝¹ : Monoid α
inst✝ : Monoid β
l : List α
comm✝ : Set.Pairwise {x | x ∈ ↑l} Commute
comm : Set.Pairwise {x | x ∈ ↑[]} Commute
⊢ List.foldr (fun x x_1 => x * x_1) 1 [] = List.prod []

tactic: rw [List.prod_cons, List.foldr, hl]
state_before: case cons
F : Type ?u.7239
ι : Type ?u.7242
α : Type u_1
β : Type ?u.7248
γ : Type ?u.7251
f : α → β → β
op : α → α → α
inst✝¹ : Monoid α
inst✝ : Monoid β
l : List α
comm✝ : Set.Pairwise {x | x ∈ ↑l} Commute
hd : α
tl : List α
hl : Set.Pairwise {x | x ∈ ↑tl} Commute → List.foldr (fun x x_1 => x * x_1) 1 tl = List.prod tl
comm : Set.Pairwise {x | x ∈ ↑(hd :: tl)} Commute
⊢ List.foldr (fun x x_1 => x * x_1) 1 (hd :: tl) = List.prod (hd :: tl)

tactic: intro x hx y hy
state_before: case cons
F : Type ?u.7239
ι : Type ?u.7242
α : Type u_1
β : Type ?u.7248
γ : Type ?u.7251
f : α → β → β
op : α → α → α
inst✝¹ : Monoid α
inst✝ : Monoid β
l : List α
comm✝ : Set.Pairwise {x | x ∈ ↑l} Commute
hd : α
tl : List α
hl : Set.Pairwise {x | x ∈ ↑tl} Commute → List.foldr (fun x x_1 => x * x_1) 1 tl = List.prod tl
comm : Set.Pairwise {x | x ∈ ↑(hd :: tl)} Commute
⊢ Set.Pairwise {x | x ∈ ↑tl} Commute

tactic: exact comm (List.mem_cons_of_mem _ hx) (List.mem_cons_of_mem _ hy)
state_before: case cons
F : Type ?u.7239
ι : Type ?u.7242
α : Type u_1
β : Type ?u.7248
γ : Type ?u.7251
f : α → β → β
op : α → α → α
inst✝¹ : Monoid α
inst✝ : Monoid β
l : List α
comm✝ : Set.Pairwise {x | x ∈ ↑l} Commute
hd : α
tl : List α
hl : Set.Pairwise {x | x ∈ ↑tl} Commute → List.foldr (fun x x_1 => x * x_1) 1 tl = List.prod tl
comm : Set.Pairwise {x | x ∈ ↑(hd :: tl)} Commute
x : α
hx : x ∈ {x | x ∈ ↑tl}
y : α
hy : y ∈ {x | x ∈ ↑tl}
⊢ x ≠ y → Commute x y
Theorem: MeasureTheory.L1.SimpleFunc.integrable
File: Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean

tactic: rw [← memℒp_one_iff_integrable]
state_before: α : Type u_1
β : Type ?u.3383671
ι : Type ?u.3383674
E : Type u_2
F : Type ?u.3383680
𝕜 : Type ?u.3383683
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f✝ : α → E
p : ℝ≥0∞
μ : Measure α
f : { x // x ∈ Lp.simpleFunc E 1 μ }
⊢ Integrable ↑(Lp.simpleFunc.toSimpleFunc f)

tactic: exact Lp.simpleFunc.memℒp f
state_before: α : Type u_1
β : Type ?u.3383671
ι : Type ?u.3383674
E : Type u_2
F : Type ?u.3383680
𝕜 : Type ?u.3383683
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f✝ : α → E
p : ℝ≥0∞
μ : Measure α
f : { x // x ∈ Lp.simpleFunc E 1 μ }
⊢ Memℒp (↑(Lp.simpleFunc.toSimpleFunc f)) 1
Theorem: OrderIso.essSup_apply
File: Mathlib/MeasureTheory/Function/EssSup.lean

tactic: refine' OrderIso.limsup_apply g _ _ _ _
state_before: α : Type u_1
β : Type u_3
m✝ : MeasurableSpace α
μ✝ ν : MeasureTheory.Measure α
inst✝¹ : CompleteLattice β
m : MeasurableSpace α
γ : Type u_2
inst✝ : CompleteLattice γ
f : α → β
μ : MeasureTheory.Measure α
g : β ≃o γ
⊢ ↑g (essSup f μ) = essSup (fun x => ↑g (f x)) μ

tactic: all_goals isBoundedDefault
state_before: case refine'_1
α : Type u_1
β : Type u_3
m✝ : MeasurableSpace α
μ✝ ν : MeasureTheory.Measure α
inst✝¹ : CompleteLattice β
m : MeasurableSpace α
γ : Type u_2
inst✝ : CompleteLattice γ
f : α → β
μ : MeasureTheory.Measure α
g : β ≃o γ
⊢ IsBoundedUnder (fun x x_1 => x ≤ x_1) (Measure.ae μ) f

case refine'_2
α : Type u_1
β : Type u_3
m✝ : MeasurableSpace α
μ✝ ν : MeasureTheory.Measure α
inst✝¹ : CompleteLattice β
m : MeasurableSpace α
γ : Type u_2
inst✝ : CompleteLattice γ
f : α → β
μ : MeasureTheory.Measure α
g : β ≃o γ
⊢ IsCoboundedUnder (fun x x_1 => x ≤ x_1) (Measure.ae μ) f

case refine'_3
α : Type u_1
β : Type u_3
m✝ : MeasurableSpace α
μ✝ ν : MeasureTheory.Measure α
inst✝¹ : CompleteLattice β
m : MeasurableSpace α
γ : Type u_2
inst✝ : CompleteLattice γ
f : α → β
μ : MeasureTheory.Measure α
g : β ≃o γ
⊢ IsBoundedUnder (fun x x_1 => x ≤ x_1) (Measure.ae μ) fun x => ↑g (f x)

case refine'_4
α : Type u_1
β : Type u_3
m✝ : MeasurableSpace α
μ✝ ν : MeasureTheory.Measure α
inst✝¹ : CompleteLattice β
m : MeasurableSpace α
γ : Type u_2
inst✝ : CompleteLattice γ
f : α → β
μ : MeasureTheory.Measure α
g : β ≃o γ
⊢ IsCoboundedUnder (fun x x_1 => x ≤ x_1) (Measure.ae μ) fun x => ↑g (f x)

tactic: isBoundedDefault
state_before: case refine'_4
α : Type u_1
β : Type u_3
m✝ : MeasurableSpace α
μ✝ ν : MeasureTheory.Measure α
inst✝¹ : CompleteLattice β
m : MeasurableSpace α
γ : Type u_2
inst✝ : CompleteLattice γ
f : α → β
μ : MeasureTheory.Measure α
g : β ≃o γ
⊢ IsCoboundedUnder (fun x x_1 => x ≤ x_1) (Measure.ae μ) fun x => ↑g (f x)
Theorem: Cardinal.mul_eq_max
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: simpa only [mul_one] using mul_le_mul_left' (one_le_aleph0.trans hb) a
state_before: a b : Cardinal
ha : ℵ₀ ≤ a
hb : ℵ₀ ≤ b
⊢ a ≤ a * b

tactic: simpa only [one_mul] using mul_le_mul_right' (one_le_aleph0.trans ha) b
state_before: a b : Cardinal
ha : ℵ₀ ≤ a
hb : ℵ₀ ≤ b
⊢ b ≤ a * b