tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.integrable_norm_iff
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: simp_rw [Integrable, and_iff_right hf, and_iff_right hf.norm, hasFiniteIntegral_norm_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.984360
δ : Type ?u.984363
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
hf : AEStronglyMeasurable f μ
⊢ (Integrable fun a => ‖f a‖) ↔ Integrable f
Theorem: Int.cast_nonpos
File: Mathlib/Data/Int/Cast/Lemmas.lean

tactic: rw [← cast_zero, cast_le]
state_before: F : Type ?u.18184
ι : Type ?u.18187
α : Type u_1
β : Type ?u.18193
inst✝¹ : OrderedRing α
inst✝ : Nontrivial α
n : ℤ
⊢ ↑n ≤ 0 ↔ n ≤ 0
Theorem: Nat.Linear.Certificate.of_combine
File: src/lean/Init/Data/Nat/Linear.lean

tactic: match cs with
| [] => simp [combine, PolyCnstr.denote, Poly.denote_eq] at h
| (k, c)::cs =>
  simp [denote, combine] at *
  intro h'
  apply of_combineHyps (h := h)
  simp [h']
state_before: ctx : Context
cs : Certificate
h : PolyCnstr.denote ctx (combine cs) → False
⊢ denote ctx cs

tactic: simp [combine, PolyCnstr.denote, Poly.denote_eq] at h
state_before: ctx : Context
cs : Certificate
h : PolyCnstr.denote ctx (combine []) → False
⊢ denote ctx []

tactic: simp [denote, combine] at *
state_before: ctx : Context
cs✝ : Certificate
k : Nat
c : ExprCnstr
cs : List (Nat × ExprCnstr)
h : PolyCnstr.denote ctx (combine ((k, c) :: cs)) → False
⊢ denote ctx ((k, c) :: cs)

tactic: intro h'
state_before: ctx : Context
cs✝ : Certificate
k : Nat
c : ExprCnstr
cs : List (Nat × ExprCnstr)
h : PolyCnstr.denote ctx (combineHyps (PolyCnstr.mul (k + 1) (ExprCnstr.toNormPoly c)) cs) → False
⊢ ExprCnstr.denote ctx c → denote ctx cs

tactic: apply of_combineHyps (h := h)
state_before: ctx : Context
cs✝ : Certificate
k : Nat
c : ExprCnstr
cs : List (Nat × ExprCnstr)
h : PolyCnstr.denote ctx (combineHyps (PolyCnstr.mul (k + 1) (ExprCnstr.toNormPoly c)) cs) → False
h' : ExprCnstr.denote ctx c
⊢ denote ctx cs

tactic: simp [h']
state_before: ctx : Context
cs✝ : Certificate
k : Nat
c : ExprCnstr
cs : List (Nat × ExprCnstr)
h : PolyCnstr.denote ctx (combineHyps (PolyCnstr.mul (k + 1) (ExprCnstr.toNormPoly c)) cs) → False
h' : ExprCnstr.denote ctx c
⊢ PolyCnstr.denote ctx (PolyCnstr.mul (k + 1) (ExprCnstr.toNormPoly c))
Theorem: NormedAddGroupHom.Equalizer.comp_ι_eq
File: Mathlib/Analysis/Normed/Group/Hom.lean

tactic: ext x
state_before: V : Type u_1
W : Type u_2
V₁ : Type ?u.501676
V₂ : Type ?u.501679
V₃ : Type ?u.501682
inst✝⁷ : SeminormedAddCommGroup V
inst✝⁶ : SeminormedAddCommGroup W
inst✝⁵ : SeminormedAddCommGroup V₁
inst✝⁴ : SeminormedAddCommGroup V₂
inst✝³ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V W
W₁ : Type ?u.501714
W₂ : Type ?u.501717
W₃ : Type ?u.501720
inst✝² : SeminormedAddCommGroup W₁
inst✝¹ : SeminormedAddCommGroup W₂
inst✝ : SeminormedAddCommGroup W₃
g : NormedAddGroupHom V W
f₁ g₁ : NormedAddGroupHom V₁ W₁
f₂ g₂ : NormedAddGroupHom V₂ W₂
f₃ g₃ : NormedAddGroupHom V₃ W₃
⊢ NormedAddGroupHom.comp f (ι f g) = NormedAddGroupHom.comp g (ι f g)

tactic: rw [comp_apply, comp_apply, ← sub_eq_zero, ← NormedAddGroupHom.sub_apply]
state_before: case H
V : Type u_1
W : Type u_2
V₁ : Type ?u.501676
V₂ : Type ?u.501679
V₃ : Type ?u.501682
inst✝⁷ : SeminormedAddCommGroup V
inst✝⁶ : SeminormedAddCommGroup W
inst✝⁵ : SeminormedAddCommGroup V₁
inst✝⁴ : SeminormedAddCommGroup V₂
inst✝³ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V W
W₁ : Type ?u.501714
W₂ : Type ?u.501717
W₃ : Type ?u.501720
inst✝² : SeminormedAddCommGroup W₁
inst✝¹ : SeminormedAddCommGroup W₂
inst✝ : SeminormedAddCommGroup W₃
g : NormedAddGroupHom V W
f₁ g₁ : NormedAddGroupHom V₁ W₁
f₂ g₂ : NormedAddGroupHom V₂ W₂
f₃ g₃ : NormedAddGroupHom V₃ W₃
x : { x // x ∈ equalizer f g }
⊢ ↑(NormedAddGroupHom.comp f (ι f g)) x = ↑(NormedAddGroupHom.comp g (ι f g)) x

tactic: exact x.2
state_before: case H
V : Type u_1
W : Type u_2
V₁ : Type ?u.501676
V₂ : Type ?u.501679
V₃ : Type ?u.501682
inst✝⁷ : SeminormedAddCommGroup V
inst✝⁶ : SeminormedAddCommGroup W
inst✝⁵ : SeminormedAddCommGroup V₁
inst✝⁴ : SeminormedAddCommGroup V₂
inst✝³ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V W
W₁ : Type ?u.501714
W₂ : Type ?u.501717
W₃ : Type ?u.501720
inst✝² : SeminormedAddCommGroup W₁
inst✝¹ : SeminormedAddCommGroup W₂
inst✝ : SeminormedAddCommGroup W₃
g : NormedAddGroupHom V W
f₁ g₁ : NormedAddGroupHom V₁ W₁
f₂ g₂ : NormedAddGroupHom V₂ W₂
f₃ g₃ : NormedAddGroupHom V₃ W₃
x : { x // x ∈ equalizer f g }
⊢ ↑(f - g) (↑(ι f g) x) = 0
Theorem: MeasureTheory.OuterMeasure.biInf_apply
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: haveI := hI.to_subtype
state_before: α : Type u_2
ι : Type u_1
I : Set ι
hI : Set.Nonempty I
m : ι → OuterMeasure α
s : Set α
⊢ ↑(⨅ (i : ι) (_ : i ∈ I), m i) s =
    ⨅ (t : ℕ → Set α) (_ : s ⊆ iUnion t), ∑' (n : ℕ), ⨅ (i : ι) (_ : i ∈ I), ↑(m i) (t n)

tactic: simp only [← iInf_subtype'', iInf_apply]
state_before: α : Type u_2
ι : Type u_1
I : Set ι
hI : Set.Nonempty I
m : ι → OuterMeasure α
s : Set α
this : Nonempty ↑I
⊢ ↑(⨅ (i : ι) (_ : i ∈ I), m i) s =
    ⨅ (t : ℕ → Set α) (_ : s ⊆ iUnion t), ∑' (n : ℕ), ⨅ (i : ι) (_ : i ∈ I), ↑(m i) (t n)
Theorem: CategoryTheory.Limits.coprod.desc_comp_inl_comp_inr
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

tactic: rw [← coprod.map_desc]
state_before: C : Type u
inst✝² : Category C
X✝ Y✝ W X Y Z : C
inst✝¹ : HasBinaryCoproduct W Y
inst✝ : HasBinaryCoproduct X Z
g : W ⟶ X
g' : Y ⟶ Z
⊢ desc (g ≫ inl) (g' ≫ inr) = map g g'

tactic: simp
state_before: C : Type u
inst✝² : Category C
X✝ Y✝ W X Y Z : C
inst✝¹ : HasBinaryCoproduct W Y
inst✝ : HasBinaryCoproduct X Z
g : W ⟶ X
g' : Y ⟶ Z
⊢ map g g' ≫ desc inl inr = map g g'
Theorem: Dfinsupp.extendWith_single_zero
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: ext (_ | j)
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
κ : Type ?u.661354
α : Option ι → Type v
inst✝¹ : DecidableEq ι
inst✝ : (i : Option ι) → Zero (α i)
i : ι
x : α (some i)
⊢ extendWith 0 (single i x) = single (some i) x

tactic: rw [extendWith_none, single_eq_of_ne (Option.some_ne_none _)]
state_before: case h.none
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
κ : Type ?u.661354
α : Option ι → Type v
inst✝¹ : DecidableEq ι
inst✝ : (i : Option ι) → Zero (α i)
i : ι
x : α (some i)
⊢ ↑(extendWith 0 (single i x)) none = ↑(single (some i) x) none

tactic: rw [extendWith_some]
state_before: case h.some
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
κ : Type ?u.661354
α : Option ι → Type v
inst✝¹ : DecidableEq ι
inst✝ : (i : Option ι) → Zero (α i)
i : ι
x : α (some i)
j : ι
⊢ ↑(extendWith 0 (single i x)) (some j) = ↑(single (some i) x) (some j)

tactic: obtain rfl | hij := Decidable.eq_or_ne i j
state_before: case h.some
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
κ : Type ?u.661354
α : Option ι → Type v
inst✝¹ : DecidableEq ι
inst✝ : (i : Option ι) → Zero (α i)
i : ι
x : α (some i)
j : ι
⊢ ↑(single i x) j = ↑(single (some i) x) (some j)

tactic: rw [single_eq_same, single_eq_same]
state_before: case h.some.inl
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
κ : Type ?u.661354
α : Option ι → Type v
inst✝¹ : DecidableEq ι
inst✝ : (i : Option ι) → Zero (α i)
i : ι
x : α (some i)
⊢ ↑(single i x) i = ↑(single (some i) x) (some i)

tactic: rw [single_eq_of_ne hij, single_eq_of_ne ((Option.some_injective _).ne hij)]
state_before: case h.some.inr
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
κ : Type ?u.661354
α : Option ι → Type v
inst✝¹ : DecidableEq ι
inst✝ : (i : Option ι) → Zero (α i)
i : ι
x : α (some i)
j : ι
hij : i ≠ j
⊢ ↑(single i x) j = ↑(single (some i) x) (some j)
Theorem: Rat.coe_int_div_eq_divInt
File: Mathlib/Data/Rat/Defs.lean

tactic: repeat' rw [coe_int_eq_divInt]
state_before: a b c : ℚ
n d : ℤ
⊢ ↑n / ↑d = n /. d

tactic: exact divInt_div_divInt_cancel_left one_ne_zero n d
state_before: a b c : ℚ
n d : ℤ
⊢ n /. 1 / (d /. 1) = n /. d

tactic: rw [coe_int_eq_divInt]
state_before: a b c : ℚ
n d : ℤ
⊢ n /. 1 / (d /. 1) = n /. d
Theorem: Matrix.smul_eq_diagonal_mul
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type ?u.279030
m : Type u_1
n : Type u_2
o : Type ?u.279039
m' : o → Type ?u.279044
n' : o → Type ?u.279049
R : Type ?u.279052
S : Type ?u.279055
α : Type v
β : Type w
γ : Type ?u.279062
inst✝² : NonUnitalNonAssocSemiring α
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n α
a : α
⊢ a • M = (diagonal fun x => a) ⬝ M

tactic: simp
state_before: case a.h
l : Type ?u.279030
m : Type u_1
n : Type u_2
o : Type ?u.279039
m' : o → Type ?u.279044
n' : o → Type ?u.279049
R : Type ?u.279052
S : Type ?u.279055
α : Type v
β : Type w
γ : Type ?u.279062
inst✝² : NonUnitalNonAssocSemiring α
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n α
a : α
i✝ : m
x✝ : n
⊢ (a • M) i✝ x✝ = ((diagonal fun x => a) ⬝ M) i✝ x✝
Theorem: cauchyPowerSeries_apply
File: Mathlib/MeasureTheory/Integral/CircleIntegral.lean

tactic: simp only [cauchyPowerSeries, ContinuousMultilinearMap.mkPiField_apply, Fin.prod_const,
  div_eq_mul_inv, mul_pow, mul_smul, circleIntegral.integral_smul]
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
c : ℂ
R : ℝ
n : ℕ
w : ℂ
⊢ (↑(cauchyPowerSeries f c R n) fun x => w) = (2 * ↑π * I)⁻¹ • ∮ (z : ℂ) in C(c, R), (w / (z - c)) ^ n • (z - c)⁻¹ • f z

tactic: rw [← smul_comm (w ^ n)]
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
c : ℂ
R : ℝ
n : ℕ
w : ℂ
⊢ (w ^ n • (2 * ↑π * I)⁻¹ • ∮ (z : ℂ) in C(c, R), (z - c)⁻¹ ^ n • (z - c)⁻¹ • f z) =
    (2 * ↑π * I)⁻¹ • w ^ n • ∮ (z : ℂ) in C(c, R), (z - c)⁻¹ ^ n • (z - c)⁻¹ • f z
Theorem: Nat.clog_mono_right
File: Mathlib/Data/Nat/Log.lean

tactic: cases' le_or_lt b 1 with hb hb
state_before: b n m : ℕ
h : n ≤ m
⊢ clog b n ≤ clog b m

tactic: rw [clog_of_left_le_one hb]
state_before: case inl
b n m : ℕ
h : n ≤ m
hb : b ≤ 1
⊢ clog b n ≤ clog b m

tactic: exact zero_le _
state_before: case inl
b n m : ℕ
h : n ≤ m
hb : b ≤ 1
⊢ 0 ≤ clog b m

tactic: rw [← le_pow_iff_clog_le hb]
state_before: case inr
b n m : ℕ
h : n ≤ m
hb : 1 < b
⊢ clog b n ≤ clog b m

tactic: exact h.trans (le_pow_clog hb _)
state_before: case inr
b n m : ℕ
h : n ≤ m
hb : 1 < b
⊢ n ≤ b ^ clog b m
Theorem: FirstOrder.Language.BoundedFormula.not_all_isAtomic
File: Mathlib/ModelTheory/Syntax.lean

tactic: cases con
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.109819
P : Type ?u.109822
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type ?u.109850
n l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v : α → M
xs : Fin l → M
φ : BoundedFormula L α (n + 1)
con : IsAtomic (all φ)
⊢ False
Theorem: Int.neg_add_lt_left_of_lt_add
File: Std/Data/Int/Lemmas.lean

tactic: rw [Int.add_comm]
state_before: a b c : Int
h : a < b + c
⊢ -b + a < c

tactic: exact Int.sub_left_lt_of_lt_add h
state_before: a b c : Int
h : a < b + c
⊢ a + -b < c
Theorem: Option.isSome_iff_exists
File: Std/Data/Option/Lemmas.lean

tactic: cases x <;> simp [isSome]
state_before: α✝ : Type u_1
x : Option α✝
⊢ isSome x = true ↔ ∃ a, x = some a
Theorem: AlgebraicTopology.DoldKan.hσ'_naturality
File: Mathlib/AlgebraicTopology/DoldKan/Homotopies.lean

tactic: have h : n + 1 = m := hnm
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X✝ : SimplicialObject C
q n m : ℕ
hnm : ComplexShape.Rel c m n
X Y : SimplicialObject C
f : X ⟶ Y
⊢ f.app [n].op ≫ hσ' q n m hnm = hσ' q n m hnm ≫ f.app [m].op

tactic: subst h
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X✝ : SimplicialObject C
q n m : ℕ
hnm : ComplexShape.Rel c m n
X Y : SimplicialObject C
f : X ⟶ Y
h : n + 1 = m
⊢ f.app [n].op ≫ hσ' q n m hnm = hσ' q n m hnm ≫ f.app [m].op

tactic: simp only [hσ', eqToHom_refl, comp_id]
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X✝ : SimplicialObject C
q n : ℕ
X Y : SimplicialObject C
f : X ⟶ Y
hnm : ComplexShape.Rel c (n + 1) n
⊢ f.app [n].op ≫ hσ' q n (n + 1) hnm = hσ' q n (n + 1) hnm ≫ f.app [n + 1].op

tactic: unfold hσ
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X✝ : SimplicialObject C
q n : ℕ
X Y : SimplicialObject C
f : X ⟶ Y
hnm : ComplexShape.Rel c (n + 1) n
⊢ f.app [n].op ≫ hσ q n = hσ q n ≫ f.app [n + 1].op

tactic: split_ifs
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X✝ : SimplicialObject C
q n : ℕ
X Y : SimplicialObject C
f : X ⟶ Y
hnm : ComplexShape.Rel c (n + 1) n
⊢ (f.app [n].op ≫ if n < q then 0 else (-1) ^ (n - q) • σ Y { val := n - q, isLt := (_ : n - q < Nat.succ n) }) =
    (if n < q then 0 else (-1) ^ (n - q) • σ X { val := n - q, isLt := (_ : n - q < Nat.succ n) }) ≫ f.app [n + 1].op

tactic: rw [zero_comp, comp_zero]
state_before: case inl
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X✝ : SimplicialObject C
q n : ℕ
X Y : SimplicialObject C
f : X ⟶ Y
hnm : ComplexShape.Rel c (n + 1) n
h✝ : n < q
⊢ f.app [n].op ≫ 0 = 0 ≫ f.app [n + 1].op

tactic: simp only [zsmul_comp, comp_zsmul]
state_before: case inr
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X✝ : SimplicialObject C
q n : ℕ
X Y : SimplicialObject C
f : X ⟶ Y
hnm : ComplexShape.Rel c (n + 1) n
h✝ : ¬n < q
⊢ f.app [n].op ≫ ((-1) ^ (n - q) • σ Y { val := n - q, isLt := (_ : n - q < Nat.succ n) }) =
    ((-1) ^ (n - q) • σ X { val := n - q, isLt := (_ : n - q < Nat.succ n) }) ≫ f.app [n + 1].op

tactic: erw [f.naturality]
state_before: case inr
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X✝ : SimplicialObject C
q n : ℕ
X Y : SimplicialObject C
f : X ⟶ Y
hnm : ComplexShape.Rel c (n + 1) n
h✝ : ¬n < q
⊢ (-1) ^ (n - q) • f.app [n].op ≫ σ Y { val := n - q, isLt := (_ : n - q < Nat.succ n) } =
    (-1) ^ (n - q) • σ X { val := n - q, isLt := (_ : n - q < Nat.succ n) } ≫ f.app [n + 1].op

tactic: rfl
state_before: case inr
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X✝ : SimplicialObject C
q n : ℕ
X Y : SimplicialObject C
f : X ⟶ Y
hnm : ComplexShape.Rel c (n + 1) n
h✝ : ¬n < q
⊢ (-1) ^ (n - q) • f.app [n].op ≫ σ Y { val := n - q, isLt := (_ : n - q < Nat.succ n) } =
    (-1) ^ (n - q) • f.app [n].op ≫ Y.map (SimplexCategory.σ { val := n - q, isLt := (_ : n - q < Nat.succ n) }).op
Theorem: Equiv.Perm.isCycleOn_support_cycleOf
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: refine fun _ ↦ ⟨fun h ↦ mem_support_cycleOf_iff.2 ?_, fun h ↦ mem_support_cycleOf_iff.2 ?_⟩
state_before: ι : Type ?u.2583510
α : Type u_1
β : Type ?u.2583516
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g : Perm α
x✝ y : α
f : Perm α
x : α
⊢ ∀ (a : α), ↑f a ∈ ↑(support (cycleOf f x)) ↔ a ∈ ↑(support (cycleOf f x))

tactic: exact ⟨sameCycle_apply_right.1 (mem_support_cycleOf_iff.1 h).1,
(mem_support_cycleOf_iff.1 h).2⟩
state_before: case refine_1
ι : Type ?u.2583510
α : Type u_1
β : Type ?u.2583516
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g : Perm α
x✝¹ y : α
f : Perm α
x x✝ : α
h : ↑f x✝ ∈ ↑(support (cycleOf f x))
⊢ SameCycle f x x✝ ∧ x ∈ support f

tactic: exact ⟨sameCycle_apply_right.2 (mem_support_cycleOf_iff.1 h).1,
(mem_support_cycleOf_iff.1 h).2⟩
state_before: case refine_2
ι : Type ?u.2583510
α : Type u_1
β : Type ?u.2583516
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g : Perm α
x✝¹ y : α
f : Perm α
x x✝ : α
h : x✝ ∈ ↑(support (cycleOf f x))
⊢ SameCycle f x (↑f x✝) ∧ x ∈ support f

tactic: rw [mem_coe, mem_support_cycleOf_iff] at ha hb
state_before: ι : Type ?u.2583510
α : Type u_1
β : Type ?u.2583516
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g : Perm α
x✝ y : α
f : Perm α
x a : α
ha : a ∈ ↑(support (cycleOf f x))
b : α
hb : b ∈ ↑(support (cycleOf f x))
⊢ SameCycle f a b

tactic: exact ha.1.symm.trans hb.1
state_before: ι : Type ?u.2583510
α : Type u_1
β : Type ?u.2583516
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g : Perm α
x✝ y : α
f : Perm α
x a : α
ha : SameCycle f x a ∧ x ∈ support f
b : α
hb : SameCycle f x b ∧ x ∈ support f
⊢ SameCycle f a b
Theorem: Finset.iInf_singleton
File: Mathlib/Data/Finset/Lattice.lean

tactic: simp
state_before: F : Type ?u.430806
α : Type u_2
β : Type u_1
γ : Type ?u.430815
ι : Type ?u.430818
κ : Type ?u.430821
inst✝ : CompleteLattice β
a : α
s : α → β
⊢ (⨅ (x : α) (_ : x ∈ {a}), s x) = s a
Theorem: ite_congr
File: src/lean/Init/SimpLemmas.lean

tactic: cases Decidable.em c with
| inl h => rw [if_pos h]; subst b; rw [if_pos h]; exact h₂ h
| inr h => rw [if_neg h]; subst b; rw [if_neg h]; exact h₃ h
state_before: α : Sort u_1
b c : Prop
x y u v : α
s : Decidable b
inst✝ : Decidable c
h₁ : b = c
h₂ : c → x = u
h₃ : ¬c → y = v
⊢ ite b x y = ite c u v

tactic: rw [if_pos h]
state_before: case inl
α : Sort u_1
b c : Prop
x y u v : α
s : Decidable b
inst✝ : Decidable c
h₁ : b = c
h₂ : c → x = u
h₃ : ¬c → y = v
h : c
⊢ ite b x y = ite c u v

tactic: subst b
state_before: case inl
α : Sort u_1
b c : Prop
x y u v : α
s : Decidable b
inst✝ : Decidable c
h₁ : b = c
h₂ : c → x = u
h₃ : ¬c → y = v
h : c
⊢ ite b x y = u

tactic: rw [if_pos h]
state_before: case inl
α : Sort u_1
c : Prop
x y u v : α
inst✝ : Decidable c
h₂ : c → x = u
h₃ : ¬c → y = v
h : c
s : Decidable c
⊢ ite c x y = u

tactic: exact h₂ h
state_before: case inl
α : Sort u_1
c : Prop
x y u v : α
inst✝ : Decidable c
h₂ : c → x = u
h₃ : ¬c → y = v
h : c
s : Decidable c
⊢ x = u

tactic: rw [if_neg h]
state_before: case inr
α : Sort u_1
b c : Prop
x y u v : α
s : Decidable b
inst✝ : Decidable c
h₁ : b = c
h₂ : c → x = u
h₃ : ¬c → y = v
h : ¬c
⊢ ite b x y = ite c u v

tactic: subst b
state_before: case inr
α : Sort u_1
b c : Prop
x y u v : α
s : Decidable b
inst✝ : Decidable c
h₁ : b = c
h₂ : c → x = u
h₃ : ¬c → y = v
h : ¬c
⊢ ite b x y = v

tactic: rw [if_neg h]
state_before: case inr
α : Sort u_1
c : Prop
x y u v : α
inst✝ : Decidable c
h₂ : c → x = u
h₃ : ¬c → y = v
h : ¬c
s : Decidable c
⊢ ite c x y = v

tactic: exact h₃ h
state_before: case inr
α : Sort u_1
c : Prop
x y u v : α
inst✝ : Decidable c
h₂ : c → x = u
h₃ : ¬c → y = v
h : ¬c
s : Decidable c
⊢ y = v
Theorem: add_halves
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [div_add_div_same, ← two_mul, mul_div_cancel_left a two_ne_zero]
state_before: ι : Type ?u.89441
α : Type u_1
β : Type ?u.89447
inst✝ : LinearOrderedSemifield α
a✝ b c d e : α
m n : ℤ
a : α
⊢ a / 2 + a / 2 = a
Theorem: Finset.subset_insert_iff_of_not_mem
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [subset_insert_iff, erase_eq_of_not_mem h]
state_before: α : Type u_1
β : Type ?u.218847
γ : Type ?u.218850
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
h : ¬a ∈ s
⊢ s ⊆ insert a t ↔ s ⊆ t
Theorem: ProbabilityTheory.cond_pos_of_inter_ne_zero
File: Mathlib/Probability/ConditionalProbability.lean

tactic: rw [cond_apply _ hms]
state_before: Ω : Type u_1
m : MeasurableSpace Ω
μ : MeasureTheory.Measure Ω
s t : Set Ω
inst✝ : IsFiniteMeasure μ
hms : MeasurableSet s
hci : ↑↑μ (s ∩ t) ≠ 0
⊢ 0 < ↑↑(μ[|s]) t

tactic: refine' ENNReal.mul_pos _ hci
state_before: Ω : Type u_1
m : MeasurableSpace Ω
μ : MeasureTheory.Measure Ω
s t : Set Ω
inst✝ : IsFiniteMeasure μ
hms : MeasurableSet s
hci : ↑↑μ (s ∩ t) ≠ 0
⊢ 0 < (↑↑μ s)⁻¹ * ↑↑μ (s ∩ t)

tactic: exact ENNReal.inv_ne_zero.mpr (measure_ne_top _ _)
state_before: Ω : Type u_1
m : MeasurableSpace Ω
μ : MeasureTheory.Measure Ω
s t : Set Ω
inst✝ : IsFiniteMeasure μ
hms : MeasurableSet s
hci : ↑↑μ (s ∩ t) ≠ 0
⊢ (↑↑μ s)⁻¹ ≠ 0
Theorem: surjOn_Ici_of_monotone_surjective
File: Mathlib/Data/Set/Intervals/SurjOn.lean

tactic: rw [← Ioi_union_left, ← Ioi_union_left]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : PartialOrder β
f : α → β
h_mono : Monotone f
h_surj : Surjective f
a : α
⊢ SurjOn f (Ici a) (Ici (f a))

tactic: exact
  (surjOn_Ioi_of_monotone_surjective h_mono h_surj a).union_union
    (@image_singleton _ _ f a ▸ surjOn_image _ _)
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : PartialOrder β
f : α → β
h_mono : Monotone f
h_surj : Surjective f
a : α
⊢ SurjOn f (Ioi a ∪ {a}) (Ioi (f a) ∪ {f a})
Theorem: mul_le_mul_of_nonpos_right
File: Mathlib/Algebra/Order/Ring/Defs.lean

tactic: simpa only [mul_neg, neg_le_neg_iff] using mul_le_mul_of_nonneg_right h (neg_nonneg.2 hc)
state_before: α : Type u
β : Type ?u.34618
inst✝ : OrderedRing α
a b c d : α
h : b ≤ a
hc : c ≤ 0
⊢ a * c ≤ b * c
Theorem: Fin.castAdd_lt
File: Mathlib/Data/Fin/Basic.lean

tactic: simp
state_before: n✝ m✝ m n : ℕ
i : Fin m
⊢ ↑(↑(castAdd n) i) < m
Theorem: MeasurableSet.const_smul₀
File: Mathlib/MeasureTheory/Group/Pointwise.lean

tactic: rcases eq_or_ne a 0 with (rfl | ha)
state_before: G₀ : Type u_1
α : Type u_2
inst✝⁶ : GroupWithZero G₀
inst✝⁵ : Zero α
inst✝⁴ : MulActionWithZero G₀ α
inst✝³ : MeasurableSpace G₀
inst✝² : MeasurableSpace α
inst✝¹ : MeasurableSMul G₀ α
inst✝ : MeasurableSingletonClass α
s : Set α
hs : MeasurableSet s
a : G₀
⊢ MeasurableSet (a • s)

tactic: exacts [(subsingleton_zero_smul_set s).measurableSet, hs.const_smul_of_ne_zero ha]
state_before: case inl
G₀ : Type u_1
α : Type u_2
inst✝⁶ : GroupWithZero G₀
inst✝⁵ : Zero α
inst✝⁴ : MulActionWithZero G₀ α
inst✝³ : MeasurableSpace G₀
inst✝² : MeasurableSpace α
inst✝¹ : MeasurableSMul G₀ α
inst✝ : MeasurableSingletonClass α
s : Set α
hs : MeasurableSet s
⊢ MeasurableSet (0 • s)

case inr
G₀ : Type u_1
α : Type u_2
inst✝⁶ : GroupWithZero G₀
inst✝⁵ : Zero α
inst✝⁴ : MulActionWithZero G₀ α
inst✝³ : MeasurableSpace G₀
inst✝² : MeasurableSpace α
inst✝¹ : MeasurableSMul G₀ α
inst✝ : MeasurableSingletonClass α
s : Set α
hs : MeasurableSet s
a : G₀
ha : a ≠ 0
⊢ MeasurableSet (a • s)
Theorem: Real.range_arcsin
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

tactic: rw [arcsin, range_comp Subtype.val]
state_before: ⊢ range arcsin = Icc (-(π / 2)) (π / 2)

tactic: simp [Icc]
state_before: ⊢ Subtype.val '' range (IccExtend arcsin.proof_2 ↑(OrderIso.symm sinOrderIso)) = Icc (-(π / 2)) (π / 2)
Theorem: Filter.tendsto_Iio_atBot
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: rw [atBot_Iio_eq, tendsto_comap_iff]
state_before: ι : Type ?u.334826
ι' : Type ?u.334829
α : Type u_1
β : Type u_2
γ : Type ?u.334838
inst✝ : SemilatticeInf α
a : α
f : β → ↑(Iio a)
l : Filter β
⊢ Tendsto f l atBot ↔ Tendsto (fun x => ↑(f x)) l atBot

tactic: rfl
state_before: ι : Type ?u.334826
ι' : Type ?u.334829
α : Type u_1
β : Type u_2
γ : Type ?u.334838
inst✝ : SemilatticeInf α
a : α
f : β → ↑(Iio a)
l : Filter β
⊢ Tendsto (Subtype.val ∘ f) l atBot ↔ Tendsto (fun x => ↑(f x)) l atBot
Theorem: NormedRing.inverse_add
File: Mathlib/Analysis/NormedSpace/Units.lean

tactic: nontriviality R
state_before: R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
x : Rˣ
⊢ ∀ᶠ (t : R) in 𝓝 0, inverse (↑x + t) = inverse (1 + ↑x⁻¹ * t) * ↑x⁻¹

tactic: rw [Metric.eventually_nhds_iff]
state_before: R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
x : Rˣ
✝ : Nontrivial R
⊢ ∀ᶠ (t : R) in 𝓝 0, inverse (↑x + t) = inverse (1 + ↑x⁻¹ * t) * ↑x⁻¹

tactic: refine ⟨‖(↑x⁻¹ : R)‖⁻¹, by cancel_denoms, fun t ht ↦ ?_⟩
state_before: R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
x : Rˣ
✝ : Nontrivial R
⊢ ∃ ε, ε > 0 ∧ ∀ ⦃y : R⦄, dist y 0 < ε → inverse (↑x + y) = inverse (1 + ↑x⁻¹ * y) * ↑x⁻¹

tactic: rw [dist_zero_right] at ht
state_before: R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
x : Rˣ
✝ : Nontrivial R
t : R
ht : dist t 0 < ‖↑x⁻¹‖⁻¹
⊢ inverse (↑x + t) = inverse (1 + ↑x⁻¹ * t) * ↑x⁻¹

tactic: rw [← x.add_val t ht, inverse_unit, Units.add, Units.copy_eq, mul_inv_rev, Units.val_mul,
  ← inverse_unit, Units.oneSub_val, sub_neg_eq_add]
state_before: R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
x : Rˣ
✝ : Nontrivial R
t : R
ht : ‖t‖ < ‖↑x⁻¹‖⁻¹
⊢ inverse (↑x + t) = inverse (1 + ↑x⁻¹ * t) * ↑x⁻¹

tactic: cancel_denoms
state_before: R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
x : Rˣ
✝ : Nontrivial R
⊢ ‖↑x⁻¹‖⁻¹ > 0