tasksource/leandojo huggingface dataset:
Theorem: Finset.SupIndep.attach
File: Mathlib/Order/SupIndep.lean

tactic: intro t _ i _ hi
state_before: α : Type u_1
β : Type ?u.16631
ι : Type u_2
ι' : Type ?u.16637
inst✝¹ : Lattice α
inst✝ : OrderBot α
s t : Finset ι
f : ι → α
i : ι
hs : SupIndep s f
⊢ SupIndep (Finset.attach s) (f ∘ Subtype.val)

tactic: classical
  rw [← Finset.sup_image]
  refine' hs (image_subset_iff.2 fun (j : { x // x ∈ s }) _ => j.2) i.2 fun hi' => hi _
  rw [mem_image] at hi'
  obtain ⟨j, hj, hji⟩ := hi'
  rwa [Subtype.ext hji] at hj
state_before: α : Type u_1
β : Type ?u.16631
ι : Type u_2
ι' : Type ?u.16637
inst✝¹ : Lattice α
inst✝ : OrderBot α
s t✝ : Finset ι
f : ι → α
i✝ : ι
hs : SupIndep s f
t : Finset { x // x ∈ s }
a✝¹ : t ⊆ Finset.attach s
i : { x // x ∈ s }
a✝ : i ∈ Finset.attach s
hi : ¬i ∈ t
⊢ Disjoint ((f ∘ Subtype.val) i) (sup t (f ∘ Subtype.val))

tactic: rw [← Finset.sup_image]
state_before: α : Type u_1
β : Type ?u.16631
ι : Type u_2
ι' : Type ?u.16637
inst✝¹ : Lattice α
inst✝ : OrderBot α
s t✝ : Finset ι
f : ι → α
i✝ : ι
hs : SupIndep s f
t : Finset { x // x ∈ s }
a✝¹ : t ⊆ Finset.attach s
i : { x // x ∈ s }
a✝ : i ∈ Finset.attach s
hi : ¬i ∈ t
⊢ Disjoint ((f ∘ Subtype.val) i) (sup t (f ∘ Subtype.val))

tactic: refine' hs (image_subset_iff.2 fun (j : { x // x ∈ s }) _ => j.2) i.2 fun hi' => hi _
state_before: α : Type u_1
β : Type ?u.16631
ι : Type u_2
ι' : Type ?u.16637
inst✝¹ : Lattice α
inst✝ : OrderBot α
s t✝ : Finset ι
f : ι → α
i✝ : ι
hs : SupIndep s f
t : Finset { x // x ∈ s }
a✝¹ : t ⊆ Finset.attach s
i : { x // x ∈ s }
a✝ : i ∈ Finset.attach s
hi : ¬i ∈ t
⊢ Disjoint ((f ∘ Subtype.val) i) (sup (image Subtype.val t) f)

tactic: rw [mem_image] at hi'
state_before: α : Type u_1
β : Type ?u.16631
ι : Type u_2
ι' : Type ?u.16637
inst✝¹ : Lattice α
inst✝ : OrderBot α
s t✝ : Finset ι
f : ι → α
i✝ : ι
hs : SupIndep s f
t : Finset { x // x ∈ s }
a✝¹ : t ⊆ Finset.attach s
i : { x // x ∈ s }
a✝ : i ∈ Finset.attach s
hi : ¬i ∈ t
hi' : ↑i ∈ image (fun j => ↑j) t
⊢ i ∈ t

tactic: obtain ⟨j, hj, hji⟩ := hi'
state_before: α : Type u_1
β : Type ?u.16631
ι : Type u_2
ι' : Type ?u.16637
inst✝¹ : Lattice α
inst✝ : OrderBot α
s t✝ : Finset ι
f : ι → α
i✝ : ι
hs : SupIndep s f
t : Finset { x // x ∈ s }
a✝¹ : t ⊆ Finset.attach s
i : { x // x ∈ s }
a✝ : i ∈ Finset.attach s
hi : ¬i ∈ t
hi' : ∃ a, a ∈ t ∧ ↑a = ↑i
⊢ i ∈ t

tactic: rwa [Subtype.ext hji] at hj
state_before: case intro.intro
α : Type u_1
β : Type ?u.16631
ι : Type u_2
ι' : Type ?u.16637
inst✝¹ : Lattice α
inst✝ : OrderBot α
s t✝ : Finset ι
f : ι → α
i✝ : ι
hs : SupIndep s f
t : Finset { x // x ∈ s }
a✝¹ : t ⊆ Finset.attach s
i : { x // x ∈ s }
a✝ : i ∈ Finset.attach s
hi : ¬i ∈ t
j : { x // x ∈ s }
hj : j ∈ t
hji : ↑j = ↑i
⊢ i ∈ t
Theorem: OneOneReducible.of_equiv_symm
File: Mathlib/Computability/Reduce.lean

tactic: convert OneOneReducible.of_equiv _ h
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable β
e : α ≃ β
q : β → Prop
h : Computable ↑e.symm
⊢ q ≤₁ (q ∘ ↑e)

tactic: funext
state_before: case h.e'_5
α : Type u_1
β : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable β
e : α ≃ β
q : β → Prop
h : Computable ↑e.symm
⊢ q = (q ∘ ↑e) ∘ ↑e.symm

tactic: simp
state_before: case h.e'_5.h
α : Type u_1
β : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable β
e : α ≃ β
q : β → Prop
h : Computable ↑e.symm
x✝ : β
⊢ q x✝ = ((q ∘ ↑e) ∘ ↑e.symm) x✝
Theorem: List.filter_append_perm
File: Mathlib/Data/List/Perm.lean

tactic: induction' l with x l ih
state_before: α : Type uu
β : Type vv
l₁ l₂ : List α
p : α → Bool
l : List α
⊢ filter p l ++ filter (fun x => decide ¬p x = true) l ~ l

tactic: rfl
state_before: case nil
α : Type uu
β : Type vv
l₁ l₂ : List α
p : α → Bool
⊢ filter p [] ++ filter (fun x => decide ¬p x = true) [] ~ []

tactic: by_cases h : p x
state_before: case cons
α : Type uu
β : Type vv
l₁ l₂ : List α
p : α → Bool
x : α
l : List α
ih : filter p l ++ filter (fun x => decide ¬p x = true) l ~ l
⊢ filter p (x :: l) ++ filter (fun x => decide ¬p x = true) (x :: l) ~ x :: l

tactic: simp only [h, filter_cons_of_pos, filter_cons_of_neg, not_true, not_false_iff, cons_append]
state_before: case pos
α : Type uu
β : Type vv
l₁ l₂ : List α
p : α → Bool
x : α
l : List α
ih : filter p l ++ filter (fun x => decide ¬p x = true) l ~ l
h : p x = true
⊢ filter p (x :: l) ++ filter (fun x => decide ¬p x = true) (x :: l) ~ x :: l

tactic: exact ih.cons x
state_before: case pos
α : Type uu
β : Type vv
l₁ l₂ : List α
p : α → Bool
x : α
l : List α
ih : filter p l ++ filter (fun x => decide ¬p x = true) l ~ l
h : p x = true
⊢ x :: (filter p l ++ filter (fun x => decide ¬p x = true) l) ~ x :: l

tactic: simp only [h, filter_cons_of_neg, not_false_iff, filter_cons_of_pos]
state_before: case neg
α : Type uu
β : Type vv
l₁ l₂ : List α
p : α → Bool
x : α
l : List α
ih : filter p l ++ filter (fun x => decide ¬p x = true) l ~ l
h : ¬p x = true
⊢ filter p (x :: l) ++ filter (fun x => decide ¬p x = true) (x :: l) ~ x :: l

tactic: refine' Perm.trans _ (ih.cons x)
state_before: case neg
α : Type uu
β : Type vv
l₁ l₂ : List α
p : α → Bool
x : α
l : List α
ih : filter p l ++ filter (fun x => decide ¬p x = true) l ~ l
h : ¬p x = true
⊢ filter p l ++ x :: filter (fun x => decide ¬p x = true) l ~ x :: l

tactic: exact perm_append_comm.trans (perm_append_comm.cons _)
state_before: case neg
α : Type uu
β : Type vv
l₁ l₂ : List α
p : α → Bool
x : α
l : List α
ih : filter p l ++ filter (fun x => decide ¬p x = true) l ~ l
h : ¬p x = true
⊢ filter p l ++ x :: filter (fun x => decide ¬p x = true) l ~
    x :: (filter p l ++ filter (fun x => decide ¬p x = true) l)
Theorem: List.append_cancel_right_eq
File: src/lean/Init/Data/List/BasicAux.lean

tactic: apply propext
state_before: α : Type u_1
as bs cs : List α
⊢ (as ++ bs = cs ++ bs) = (as = cs)

tactic: apply Iff.intro
state_before: case a
α : Type u_1
as bs cs : List α
⊢ as ++ bs = cs ++ bs ↔ as = cs

tactic: next => apply append_cancel_right
state_before: case a.mp
α : Type u_1
as bs cs : List α
⊢ as ++ bs = cs ++ bs → as = cs

case a.mpr
α : Type u_1
as bs cs : List α
⊢ as = cs → as ++ bs = cs ++ bs

tactic: next => intro h; simp [h]
state_before: case a.mpr
α : Type u_1
as bs cs : List α
⊢ as = cs → as ++ bs = cs ++ bs

tactic: apply append_cancel_right
state_before: α : Type u_1
as bs cs : List α
⊢ as ++ bs = cs ++ bs → as = cs

tactic: intro h
state_before: α : Type u_1
as bs cs : List α
⊢ as = cs → as ++ bs = cs ++ bs

tactic: simp [h]
state_before: α : Type u_1
as bs cs : List α
h : as = cs
⊢ as ++ bs = cs ++ bs
Theorem: Set.mulIndicator_eq_one_or_self
File: Mathlib/Algebra/IndicatorFunction.lean

tactic: by_cases h : a ∈ s
state_before: α : Type u_1
β : Type ?u.2284
ι : Type ?u.2287
M : Type u_2
N : Type ?u.2293
inst✝¹ : One M
inst✝ : One N
s✝ t : Set α
f✝ g : α → M
a✝ : α
s : Set α
f : α → M
a : α
⊢ mulIndicator s f a = 1 ∨ mulIndicator s f a = f a

tactic: exact Or.inr (mulIndicator_of_mem h f)
state_before: case pos
α : Type u_1
β : Type ?u.2284
ι : Type ?u.2287
M : Type u_2
N : Type ?u.2293
inst✝¹ : One M
inst✝ : One N
s✝ t : Set α
f✝ g : α → M
a✝ : α
s : Set α
f : α → M
a : α
h : a ∈ s
⊢ mulIndicator s f a = 1 ∨ mulIndicator s f a = f a

tactic: exact Or.inl (mulIndicator_of_not_mem h f)
state_before: case neg
α : Type u_1
β : Type ?u.2284
ι : Type ?u.2287
M : Type u_2
N : Type ?u.2293
inst✝¹ : One M
inst✝ : One N
s✝ t : Set α
f✝ g : α → M
a✝ : α
s : Set α
f : α → M
a : α
h : ¬a ∈ s
⊢ mulIndicator s f a = 1 ∨ mulIndicator s f a = f a
Theorem: RingHom.FiniteType.comp_surjective
File: Mathlib/RingTheory/FiniteType.lean

tactic: let _ : Algebra A B := f.toAlgebra
state_before: A : Type u_1
B : Type u_2
C : Type u_3
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : CommRing C
f : A →+* B
g : B →+* C
hf : FiniteType f
hg : Surjective ↑g
⊢ FiniteType (comp g f)

tactic: let _ : Algebra A C := (g.comp f).toAlgebra
state_before: A : Type u_1
B : Type u_2
C : Type u_3
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : CommRing C
f : A →+* B
g : B →+* C
hf : FiniteType f
hg : Surjective ↑g
x✝ : Algebra A B := toAlgebra f
⊢ FiniteType (comp g f)

tactic: exact Algebra.FiniteType.of_surjective hf
  { g with
    toFun := g
    commutes' := fun a => rfl }
  hg
state_before: A : Type u_1
B : Type u_2
C : Type u_3
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : CommRing C
f : A →+* B
g : B →+* C
hf : FiniteType f
hg : Surjective ↑g
x✝¹ : Algebra A B := toAlgebra f
x✝ : Algebra A C := toAlgebra (comp g f)
⊢ FiniteType (comp g f)
Theorem: AddCommGroup.ModEq.add_iff_left
File: Mathlib/Algebra/ModEq.lean

tactic: simp [add_sub_add_comm, hm, add_smul, ModEq]
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a a₁ a₂ b b₁ b₂ c : α
n : ℕ
z : ℤ
x✝ : a₁ ≡ b₁ [PMOD p]
m : ℤ
hm : b₁ - a₁ = m • p
⊢ (∃ b, b₁ + b₂ - (a₁ + a₂) = ↑(Equiv.addLeft m).symm.symm b • p) ↔ a₂ ≡ b₂ [PMOD p]
Theorem: Multiset.add_cons
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [add_comm, cons_add, add_comm]
state_before: α : Type u_1
β : Type ?u.45497
γ : Type ?u.45500
a : α
s t : Multiset α
⊢ s + a ::ₘ t = a ::ₘ (s + t)
Theorem: isCyclic_of_orderOf_eq_card
File: Mathlib/GroupTheory/SpecificGroups/Cyclic.lean

tactic: classical
  use x
  simp_rw [← SetLike.mem_coe, ← Set.eq_univ_iff_forall]
  rw [← Fintype.card_congr (Equiv.Set.univ α), orderOf_eq_card_zpowers] at hx
  exact Set.eq_of_subset_of_card_le (Set.subset_univ _) (ge_of_eq hx)
state_before: α : Type u
a : α
inst✝¹ : Group α
inst✝ : Fintype α
x : α
hx : orderOf x = Fintype.card α
⊢ IsCyclic α

tactic: use x
state_before: α : Type u
a : α
inst✝¹ : Group α
inst✝ : Fintype α
x : α
hx : orderOf x = Fintype.card α
⊢ IsCyclic α

tactic: simp_rw [← SetLike.mem_coe, ← Set.eq_univ_iff_forall]
state_before: α : Type u
a : α
inst✝¹ : Group α
inst✝ : Fintype α
x : α
hx : orderOf x = Fintype.card α
⊢ ∀ (x_1 : α), x_1 ∈ zpowers x

tactic: rw [← Fintype.card_congr (Equiv.Set.univ α), orderOf_eq_card_zpowers] at hx
state_before: α : Type u
a : α
inst✝¹ : Group α
inst✝ : Fintype α
x : α
hx : orderOf x = Fintype.card α
⊢ ↑(zpowers x) = Set.univ

tactic: exact Set.eq_of_subset_of_card_le (Set.subset_univ _) (ge_of_eq hx)
state_before: α : Type u
a : α
inst✝¹ : Group α
inst✝ : Fintype α
x : α
hx✝ : orderOf x = Fintype.card ↑Set.univ
hx : Fintype.card { x_1 // x_1 ∈ zpowers x } = Fintype.card ↑Set.univ
⊢ ↑(zpowers x) = Set.univ
Theorem: compl_symmDiff
File: Mathlib/Order/SymmDiff.lean

tactic: simp_rw [symmDiff, compl_sup_distrib, compl_sdiff, bihimp, inf_comm]
state_before: ι : Type ?u.87749
α : Type u_1
β : Type ?u.87755
π : ι → Type ?u.87760
inst✝ : BooleanAlgebra α
a b c d : α
⊢ (a ∆ b)ᶜ = a ⇔ b
Theorem: Nat.bitwise'_zero
File: Mathlib/Init/Data/Nat/Bitwise.lean

tactic: rw [bitwise'_zero_left]
state_before: f : Bool → Bool → Bool
⊢ bitwise' f 0 0 = 0

tactic: cases f false true <;> rfl
state_before: f : Bool → Bool → Bool
⊢ (bif f false true then 0 else 0) = 0
Theorem: AbsoluteValue.le_sub
File: Mathlib/Algebra/Order/AbsoluteValue.lean

tactic: simpa using abv.add_le (a - b) b
state_before: R : Type u_2
S : Type u_1
inst✝¹ : Ring R
inst✝ : OrderedRing S
abv : AbsoluteValue R S
a b : R
⊢ ↑abv a ≤ ↑abv (a - b) + ↑abv b
Theorem: SimpleGraph.ComponentCompl.supp_injective
File: Mathlib/Combinatorics/SimpleGraph/Ends/Defs.lean

tactic: refine' ConnectedComponent.ind₂ _
state_before: V : Type u
G : SimpleGraph V
K L L' M : Set V
⊢ Function.Injective supp

tactic: rintro ⟨v, hv⟩ ⟨w, hw⟩ h
state_before: V : Type u
G : SimpleGraph V
K L L' M : Set V
⊢ ∀ (v w : ↑(Kᶜ)),
    supp (connectedComponentMk (induce (Kᶜ) G) v) = supp (connectedComponentMk (induce (Kᶜ) G) w) →
      connectedComponentMk (induce (Kᶜ) G) v = connectedComponentMk (induce (Kᶜ) G) w

tactic: simp only [Set.ext_iff, ConnectedComponent.eq, Set.mem_setOf_eq, ComponentCompl.supp] at h⊢
state_before: case mk.mk
V : Type u
G : SimpleGraph V
K L L' M : Set V
v : V
hv : v ∈ Kᶜ
w : V
hw : w ∈ Kᶜ
h :
  supp (connectedComponentMk (induce (Kᶜ) G) { val := v, property := hv }) =
    supp (connectedComponentMk (induce (Kᶜ) G) { val := w, property := hw })
⊢ connectedComponentMk (induce (Kᶜ) G) { val := v, property := hv } =
    connectedComponentMk (induce (Kᶜ) G) { val := w, property := hw }

tactic: exact ((h v).mp ⟨hv, Reachable.refl _⟩).choose_spec
state_before: case mk.mk
V : Type u
G : SimpleGraph V
K L L' M : Set V
v : V
hv : v ∈ Kᶜ
w : V
hw : w ∈ Kᶜ
h :
  ∀ (x : V),
    (∃ h, Reachable (induce (Kᶜ) G) { val := x, property := (_ : ¬x ∈ K) } { val := v, property := hv }) ↔
      ∃ h, Reachable (induce (Kᶜ) G) { val := x, property := (_ : ¬x ∈ K) } { val := w, property := hw }
⊢ Reachable (induce (Kᶜ) G) { val := v, property := hv } { val := w, property := hw }
Theorem: AddMonoidAlgebra.Left.exists_add_of_mem_support_single_mul
File: Mathlib/Algebra/MonoidAlgebra/NoZeroDivisors.lean

tactic: rwa [support_single_mul _ _ (fun y => by rw [one_mul] : ∀ y : R, 1 * y = 0 ↔ _),
  Finset.mem_map] at hx
state_before: R : Type u_2
A : Type u_1
inst✝¹ : Semiring R
inst✝ : AddLeftCancelSemigroup A
g : AddMonoidAlgebra R A
a x : A
hx : x ∈ (single a 1 * g).support
⊢ ∃ b, b ∈ g.support ∧ a + b = x

tactic: rw [one_mul]
state_before: R : Type u_2
A : Type u_1
inst✝¹ : Semiring R
inst✝ : AddLeftCancelSemigroup A
g : AddMonoidAlgebra R A
a x : A
hx : x ∈ (single a 1 * g).support
y : R
⊢ 1 * y = 0 ↔ y = 0
Theorem: Set.Icc_diff_Ioc_same
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: rw [← Icc_diff_left, diff_diff_cancel_left (singleton_subset_iff.2 <| left_mem_Icc.2 h)]
state_before: α : Type u_1
β : Type ?u.43968
inst✝ : PartialOrder α
a b c : α
h : a ≤ b
⊢ Icc a b \ Ioc a b = {a}
Theorem: SimpleGraph.edgeFinset_subset_edgeFinset
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: simp
state_before: ι : Sort ?u.107664
𝕜 : Type ?u.107667
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e : Sym2 V
G₁ G₂ : SimpleGraph V
inst✝² : Fintype ↑(edgeSet G)
inst✝¹ : Fintype ↑(edgeSet G₁)
inst✝ : Fintype ↑(edgeSet G₂)
⊢ edgeFinset G₁ ⊆ edgeFinset G₂ ↔ G₁ ≤ G₂
Theorem: MeasureTheory.mem_ℒ1_toReal_of_lintegral_ne_top
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: rw [Memℒp, snorm_one_eq_lintegral_nnnorm]
state_before: α : Type u_1
β : Type ?u.1070083
γ : Type ?u.1070086
δ : Type ?u.1070089
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ≥0∞
hfm : AEMeasurable f
hfi : (∫⁻ (x : α), f x ∂μ) ≠ ⊤
⊢ Memℒp (fun x => ENNReal.toReal (f x)) 1

tactic: exact
  ⟨(AEMeasurable.ennreal_toReal hfm).aestronglyMeasurable,
    hasFiniteIntegral_toReal_of_lintegral_ne_top hfi⟩
state_before: α : Type u_1
β : Type ?u.1070083
γ : Type ?u.1070086
δ : Type ?u.1070089
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ≥0∞
hfm : AEMeasurable f
hfi : (∫⁻ (x : α), f x ∂μ) ≠ ⊤
⊢ AEStronglyMeasurable (fun x => ENNReal.toReal (f x)) μ ∧ (∫⁻ (x : α), ↑‖ENNReal.toReal (f x)‖₊ ∂μ) < ⊤
Theorem: AffineIsometryEquiv.dist_pointReflection_self
File: Mathlib/Analysis/NormedSpace/AffineIsometry.lean

tactic: rw [dist_pointReflection_self', ← two_smul' 𝕜 (x -ᵥ y), norm_smul, ← dist_eq_norm_vsub V]
state_before: 𝕜 : Type u_3
V : Type u_2
V₁ : Type ?u.2089423
V₂ : Type ?u.2089426
V₃ : Type ?u.2089429
V₄ : Type ?u.2089432
P₁ : Type ?u.2089435
P : Type u_1
P₂ : Type ?u.2089441
P₃ : Type ?u.2089444
P₄ : Type ?u.2089447
inst✝²¹ : NormedField 𝕜
inst✝²⁰ : SeminormedAddCommGroup V
inst✝¹⁹ : SeminormedAddCommGroup V₁
inst✝¹⁸ : SeminormedAddCommGroup V₂
inst✝¹⁷ : SeminormedAddCommGroup V₃
inst✝¹⁶ : SeminormedAddCommGroup V₄
inst✝¹⁵ : NormedSpace 𝕜 V
inst✝¹⁴ : NormedSpace 𝕜 V₁
inst✝¹³ : NormedSpace 𝕜 V₂
inst✝¹² : NormedSpace 𝕜 V₃
inst✝¹¹ : NormedSpace 𝕜 V₄
inst✝¹⁰ : PseudoMetricSpace P
inst✝⁹ : MetricSpace P₁
inst✝⁸ : PseudoMetricSpace P₂
inst✝⁷ : PseudoMetricSpace P₃
inst✝⁶ : PseudoMetricSpace P₄
inst✝⁵ : NormedAddTorsor V P
inst✝⁴ : NormedAddTorsor V₁ P₁
inst✝³ : NormedAddTorsor V₂ P₂
inst✝² : NormedAddTorsor V₃ P₃
inst✝¹ : NormedAddTorsor V₄ P₄
e : P ≃ᵃⁱ[𝕜] P₂
α : Type ?u.2089971
inst✝ : TopologicalSpace α
x y : P
⊢ dist (↑(pointReflection 𝕜 x) y) y = ‖2‖ * dist x y
Theorem: closedBall_one_mul_singleton
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

tactic: simp
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ closedBall 1 δ * {x} = closedBall x δ
Theorem: Int.add_le_of_le_neg_add
File: Std/Data/Int/Lemmas.lean

tactic: have h := Int.add_le_add_left h a
state_before: a b c : Int
h : b ≤ -a + c
⊢ a + b ≤ c

tactic: rwa [Int.add_neg_cancel_left] at h
state_before: a b c : Int
h✝ : b ≤ -a + c
h : a + b ≤ a + (-a + c)
⊢ a + b ≤ c
Theorem: ADEInequality.Admissible.one_lt_sumInv
File: Mathlib/NumberTheory/ADEInequality.lean

tactic: rw [Admissible]
state_before: pqr : Multiset ℕ+
⊢ Admissible pqr → 1 < sumInv pqr

tactic: rintro (⟨p', q', H⟩ | ⟨n, H⟩ | H | H | H)
state_before: pqr : Multiset ℕ+
⊢ (∃ q r, A' q r = pqr) ∨ (∃ r, D' r = pqr) ∨ E' 3 = pqr ∨ E' 4 = pqr ∨ E' 5 = pqr → 1 < sumInv pqr

tactic: all_goals
  rw [← H, E', sumInv_pqr]
  conv_rhs => simp only [OfNat.ofNat, PNat.mk_coe]
state_before: case inr.inr.inl
pqr : Multiset ℕ+
H : E' 3 = pqr
⊢ 1 < sumInv pqr

case inr.inr.inr.inl
pqr : Multiset ℕ+
H : E' 4 = pqr
⊢ 1 < sumInv pqr

case inr.inr.inr.inr
pqr : Multiset ℕ+
H : E' 5 = pqr
⊢ 1 < sumInv pqr

tactic: rw [← H, A', sumInv_pqr, add_assoc]
state_before: case inl.intro.intro
pqr : Multiset ℕ+
p' q' : ℕ+
H : A' p' q' = pqr
⊢ 1 < sumInv pqr

tactic: simp only [lt_add_iff_pos_right, PNat.one_coe, inv_one, Nat.cast_one]
state_before: case inl.intro.intro
pqr : Multiset ℕ+
p' q' : ℕ+
H : A' p' q' = pqr
⊢ 1 < (↑↑1)⁻¹ + ((↑↑p')⁻¹ + (↑↑q')⁻¹)

tactic: apply add_pos <;> simp only [PNat.pos, Nat.cast_pos, inv_pos]
state_before: case inl.intro.intro
pqr : Multiset ℕ+
p' q' : ℕ+
H : A' p' q' = pqr
⊢ 0 < (↑↑p')⁻¹ + (↑↑q')⁻¹

tactic: rw [← H, D', sumInv_pqr]
state_before: case inr.inl.intro
pqr : Multiset ℕ+
n : ℕ+
H : D' n = pqr
⊢ 1 < sumInv pqr

tactic: conv_rhs => simp only [OfNat.ofNat, PNat.mk_coe]
state_before: case inr.inl.intro
pqr : Multiset ℕ+
n : ℕ+
H : D' n = pqr
⊢ 1 < (↑↑2)⁻¹ + (↑↑2)⁻¹ + (↑↑n)⁻¹

tactic: norm_num
state_before: case inr.inl.intro
pqr : Multiset ℕ+
n : ℕ+
H : D' n = pqr
⊢ 1 < (↑(1 + 1))⁻¹ + (↑(1 + 1))⁻¹ + (↑↑n)⁻¹

tactic: rw [← H, E', sumInv_pqr]
state_before: case inr.inr.inr.inr
pqr : Multiset ℕ+
H : E' 5 = pqr
⊢ 1 < sumInv pqr

tactic: conv_rhs => simp only [OfNat.ofNat, PNat.mk_coe]
state_before: case inr.inr.inr.inr
pqr : Multiset ℕ+
H : E' 5 = pqr
⊢ 1 < (↑↑2)⁻¹ + (↑↑3)⁻¹ + (↑↑5)⁻¹
Theorem: exists_one_lt_mul_of_lt'
File: Mathlib/Algebra/Order/Monoid/Canonical/Defs.lean

tactic: obtain ⟨c, rfl⟩ := exists_mul_of_le h.le
state_before: α : Type u
inst✝³ : MulOneClass α
inst✝² : Preorder α
inst✝¹ : ContravariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : ExistsMulOfLE α
a b : α
h : a < b
⊢ ∃ c, 1 < c ∧ a * c = b

tactic: exact ⟨c, one_lt_of_lt_mul_right h, rfl⟩
state_before: case intro
α : Type u
inst✝³ : MulOneClass α
inst✝² : Preorder α
inst✝¹ : ContravariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : ExistsMulOfLE α
a c : α
h : a < a * c
⊢ ∃ c_1, 1 < c_1 ∧ a * c_1 = a * c
Theorem: mem_nhdsSet_iff_exists
File: Mathlib/Topology/NhdsSet.lean

tactic: rw [← subset_interior_iff_mem_nhdsSet, subset_interior_iff]
state_before: α : Type u_1
β : Type ?u.9322
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t s₁ s₂ t₁ t₂ : Set α
x : α
⊢ s ∈ 𝓝ˢ t ↔ ∃ U, IsOpen U ∧ t ⊆ U ∧ U ⊆ s
Theorem: PowerSeries.constantCoeff_invOfUnit
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: rw [← coeff_zero_eq_constantCoeff_apply, coeff_invOfUnit, if_pos rfl]
state_before: R : Type u_1
inst✝ : Ring R
φ : PowerSeries R
u : Rˣ
⊢ ↑(constantCoeff R) (invOfUnit φ u) = ↑u⁻¹
Theorem: Filter.mem_comap_iff
File: Mathlib/Order/Filter/Basic.lean

tactic: rw [← image_mem_map_iff inj, map_comap_of_mem large]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.260618
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter β
m : α → β
inj : Injective m
large : range m ∈ f
S : Set α
⊢ S ∈ comap m f ↔ m '' S ∈ f
Theorem: AlternatingMap.curryLeft_same
File: Mathlib/LinearAlgebra/Alternating.lean

tactic: simp
state_before: R : Type ?u.1320421
inst✝¹⁹ : Semiring R
M : Type ?u.1320427
inst✝¹⁸ : AddCommMonoid M
inst✝¹⁷ : Module R M
N : Type ?u.1320459
inst✝¹⁶ : AddCommMonoid N
inst✝¹⁵ : Module R N
P : Type ?u.1320489
inst✝¹⁴ : AddCommMonoid P
inst✝¹³ : Module R P
M' : Type ?u.1320519
inst✝¹² : AddCommGroup M'
inst✝¹¹ : Module R M'
N' : Type ?u.1320907
inst✝¹⁰ : AddCommGroup N'
inst✝⁹ : Module R N'
ι : Type ?u.1321295
ι' : Type ?u.1321298
ι'' : Type ?u.1321301
R' : Type u_1
M'' : Type u_2
M₂'' : Type ?u.1321310
N'' : Type u_3
N₂'' : Type ?u.1321316
inst✝⁸ : CommSemiring R'
inst✝⁷ : AddCommMonoid M''
inst✝⁶ : AddCommMonoid M₂''
inst✝⁵ : AddCommMonoid N''
inst✝⁴ : AddCommMonoid N₂''
inst✝³ : Module R' M''
inst✝² : Module R' M₂''
inst✝¹ : Module R' N''
inst✝ : Module R' N₂''
n : ℕ
f : AlternatingMap R' M'' N'' (Fin (Nat.succ (Nat.succ n)))
m : M''
x : Fin n → M''
⊢ Matrix.vecCons m (Matrix.vecCons m x) 0 = Matrix.vecCons m (Matrix.vecCons m x) 1
Theorem: Set.toFinset_ssubset_univ
File: Mathlib/Data/Fintype/Basic.lean

tactic: rw [← coe_ssubset, coe_toFinset, coe_univ]
state_before: α : Type u_1
β : Type ?u.93993
γ : Type ?u.93996
s✝ t : Set α
inst✝¹ : Fintype α
s : Set α
inst✝ : Fintype ↑s
⊢ toFinset s ⊂ Finset.univ ↔ s ⊂ univ
Theorem: semiconjBy_star_star_star
File: Mathlib/Algebra/Star/Basic.lean

tactic: simp_rw [SemiconjBy, ← star_mul, star_inj, eq_comm]
state_before: R : Type u
inst✝¹ : Semigroup R
inst✝ : StarSemigroup R
x y z : R
⊢ SemiconjBy (star x) (star z) (star y) ↔ SemiconjBy x y z
Theorem: Complex.exp_nat_mul
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [Nat.cast_zero, zero_mul, exp_zero, pow_zero]
state_before: x✝ y x : ℂ
⊢ exp (↑0 * x) = exp x ^ 0

tactic: rw [pow_succ', Nat.cast_add_one, add_mul, exp_add, ← exp_nat_mul _ n, one_mul]
state_before: x✝ y x : ℂ
n : ℕ
⊢ exp (↑(Nat.succ n) * x) = exp x ^ Nat.succ n
Theorem: mul_neg_geom_sum
File: Mathlib/Algebra/GeomSum.lean

tactic: simpa using geom_sum_mul_neg (op x) n
state_before: α : Type u
inst✝ : Ring α
x : α
n : ℕ
⊢ op ((1 - x) * ∑ i in range n, x ^ i) = op (1 - x ^ n)
Theorem: Nat.dist_mul_right
File: Mathlib/Data/Nat/Dist.lean

tactic: rw [dist.def, dist.def, right_distrib, tsub_mul n, tsub_mul m]
state_before: n k m : ℕ
⊢ dist (n * k) (m * k) = dist n m * k
Theorem: RatFunc.mk_one'
File: Mathlib/FieldTheory/RatFunc.lean

tactic: rw [← IsLocalization.mk'_one (M := K[X]⁰) (FractionRing K[X]) p, ← mk_coe_def, Submonoid.coe_one]
state_before: K : Type u
inst✝¹ : CommRing K
inst✝ : IsDomain K
p : K[X]
⊢ RatFunc.mk p 1 = { toFractionRing := ↑(algebraMap K[X] (FractionRing K[X])) p }
Theorem: integrableOn_Ici_iff_integrableOn_Ioi'
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

tactic: rw [← Ioi_union_left, integrableOn_union,
  eq_true (integrableOn_singleton_iff.mpr <| Or.inr hb.lt_top), and_true_iff]
state_before: α : Type u_1
β : Type ?u.3648470
E : Type u_2
F : Type ?u.3648476
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : PartialOrder α
inst✝ : MeasurableSingletonClass α
f : α → E
μ : MeasureTheory.Measure α
a b : α
hb : ↑↑μ {b} ≠ ⊤
⊢ IntegrableOn f (Ici b) ↔ IntegrableOn f (Ioi b)
Theorem: EReal.neg_le
File: Mathlib/Data/Real/EReal.lean

tactic: rw [← neg_le_neg_iff, neg_neg]
state_before: a b : EReal
⊢ -a ≤ b ↔ -b ≤ a
Theorem: Int.card_fintype_Ioc_of_le
File: Mathlib/Data/Int/Interval.lean

tactic: rw [card_fintype_Ioc, toNat_sub_of_le h]
state_before: a b : ℤ
h : a ≤ b
⊢ ↑(Fintype.card ↑(Set.Ioc a b)) = b - a
Theorem: minpoly.one
File: Mathlib/FieldTheory/Minpoly/Field.lean

tactic: simpa only [RingHom.map_one, C_1, sub_eq_add_neg] using eq_X_sub_C B (1 : A)
state_before: A : Type u_1
B : Type u_2
inst✝³ : Field A
inst✝² : Ring B
inst✝¹ : Algebra A B
x : B
inst✝ : Nontrivial B
⊢ minpoly A 1 = X - 1