tasksource/leandojo huggingface dataset:
Theorem: mem_of_mem_permsOfList
File: Mathlib/Data/Fintype/Perm.lean

tactic: have : f = 1 := by simpa [permsOfList] using h
state_before: α : Type u_1
β : Type ?u.25960
γ : Type ?u.25963
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : Equiv.Perm α
h : f ∈ permsOfList []
heq_iff_eq : α
⊢ ↑f heq_iff_eq ≠ heq_iff_eq → heq_iff_eq ∈ []

tactic: rw [this]
state_before: α : Type u_1
β : Type ?u.25960
γ : Type ?u.25963
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : Equiv.Perm α
h : f ∈ permsOfList []
heq_iff_eq : α
this : f = 1
⊢ ↑f heq_iff_eq ≠ heq_iff_eq → heq_iff_eq ∈ []

tactic: simp
state_before: α : Type u_1
β : Type ?u.25960
γ : Type ?u.25963
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : Equiv.Perm α
h : f ∈ permsOfList []
heq_iff_eq : α
this : f = 1
⊢ ↑1 heq_iff_eq ≠ heq_iff_eq → heq_iff_eq ∈ []

tactic: simpa [permsOfList] using h
state_before: α : Type u_1
β : Type ?u.25960
γ : Type ?u.25963
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : Equiv.Perm α
h : f ∈ permsOfList []
heq_iff_eq : α
⊢ f = 1

tactic: simp [hxa]
state_before: α : Type u_1
β : Type ?u.25960
γ : Type ?u.25963
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
a : α
l : List α
f : Equiv.Perm α
h✝ : f ∈ permsOfList (a :: l)
x : α
h : f ∈ List.bind l fun b => List.map (fun f => Equiv.swap a b * f) (permsOfList l)
hx : ↑f x ≠ x
y : α
hy : y ∈ l
hy' : f ∈ List.map (fun f => Equiv.swap a y * f) (permsOfList l)
g : Equiv.Perm α
hg₁ : g ∈ permsOfList l
hg₂ : Equiv.swap a y * g = f
hxa : x = a
⊢ x ∈ a :: l

tactic: rwa [hxy]
state_before: α : Type u_1
β : Type ?u.25960
γ : Type ?u.25963
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
a : α
l : List α
f : Equiv.Perm α
h✝ : f ∈ permsOfList (a :: l)
x : α
h : f ∈ List.bind l fun b => List.map (fun f => Equiv.swap a b * f) (permsOfList l)
hx : ↑f x ≠ x
y : α
hy : y ∈ l
hy' : f ∈ List.map (fun f => Equiv.swap a y * f) (permsOfList l)
g : Equiv.Perm α
hg₁ : g ∈ permsOfList l
hg₂ : Equiv.swap a y * g = f
hxa : ¬x = a
hxy : x = y
⊢ x ∈ l

tactic: rw [eq_inv_mul_iff_mul_eq.2 hg₂, mul_apply, swap_inv, swap_apply_def]
state_before: α : Type u_1
β : Type ?u.25960
γ : Type ?u.25963
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
a : α
l : List α
f : Equiv.Perm α
h✝ : f ∈ permsOfList (a :: l)
x : α
h : f ∈ List.bind l fun b => List.map (fun f => Equiv.swap a b * f) (permsOfList l)
hx : ↑f x ≠ x
y : α
hy : y ∈ l
hy' : f ∈ List.map (fun f => Equiv.swap a y * f) (permsOfList l)
g : Equiv.Perm α
hg₁ : g ∈ permsOfList l
hg₂ : Equiv.swap a y * g = f
hxa : ¬x = a
hxy : ¬x = y
⊢ ↑g x ≠ x

tactic: split_ifs <;> [exact Ne.symm hxy; exact Ne.symm hxa; exact hx]
state_before: α : Type u_1
β : Type ?u.25960
γ : Type ?u.25963
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
a : α
l : List α
f : Equiv.Perm α
h✝ : f ∈ permsOfList (a :: l)
x : α
h : f ∈ List.bind l fun b => List.map (fun f => Equiv.swap a b * f) (permsOfList l)
hx : ↑f x ≠ x
y : α
hy : y ∈ l
hy' : f ∈ List.map (fun f => Equiv.swap a y * f) (permsOfList l)
g : Equiv.Perm α
hg₁ : g ∈ permsOfList l
hg₂ : Equiv.swap a y * g = f
hxa : ¬x = a
hxy : ¬x = y
⊢ (if ↑f x = a then y else if ↑f x = y then a else ↑f x) ≠ x
Theorem: SimpleGraph.iSup_adj
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: simp [iSup]
state_before: ι : Sort u_1
𝕜 : Type ?u.18891
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
f : ι → SimpleGraph V
⊢ Adj (⨆ (i : ι), f i) a b ↔ ∃ i, Adj (f i) a b
Theorem: Nat.ArithmeticFunction.moebius_mul_coe_zeta
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: ext n
state_before: R : Type ?u.598712
⊢ μ * ↑ζ = 1

tactic: refine' recOnPosPrimePosCoprime _ _ _ _ n
state_before: case h
R : Type ?u.598712
n : ℕ
⊢ ↑(μ * ↑ζ) n = ↑1 n

tactic: intro p n hp hn
state_before: case h.refine'_1
R : Type ?u.598712
n : ℕ
⊢ ∀ (p n : ℕ), Prime p → 0 < n → ↑(μ * ↑ζ) (p ^ n) = ↑1 (p ^ n)

tactic: rw [coe_mul_zeta_apply, sum_divisors_prime_pow hp, sum_range_succ']
state_before: case h.refine'_1
R : Type ?u.598712
n✝ p n : ℕ
hp : Prime p
hn : 0 < n
⊢ ↑(μ * ↑ζ) (p ^ n) = ↑1 (p ^ n)

tactic: simp_rw [Function.Embedding.coeFn_mk, pow_zero, moebius_apply_one,
  moebius_apply_prime_pow hp (Nat.succ_ne_zero _), Nat.succ_inj', sum_ite_eq', mem_range,
  if_pos hn, add_left_neg]
state_before: case h.refine'_1
R : Type ?u.598712
n✝ p n : ℕ
hp : Prime p
hn : 0 < n
⊢ ∑ k in range n, ↑μ (p ^ (k + 1)) + ↑μ (p ^ 0) = ↑1 (p ^ n)

tactic: rw [one_apply_ne]
state_before: case h.refine'_1
R : Type ?u.598712
n✝ p n : ℕ
hp : Prime p
hn : 0 < n
⊢ 0 = ↑1 (p ^ n)

tactic: rw [Ne.def, pow_eq_one_iff]
state_before: case h.refine'_1
R : Type ?u.598712
n✝ p n : ℕ
hp : Prime p
hn : 0 < n
⊢ p ^ n ≠ 1

tactic: exact hp.ne_one
state_before: case h.refine'_1
R : Type ?u.598712
n✝ p n : ℕ
hp : Prime p
hn : 0 < n
⊢ ¬p = 1

tactic: exact hn.ne'
state_before: case h.refine'_1
R : Type ?u.598712
n✝ p n : ℕ
hp : Prime p
hn : 0 < n
⊢ n ≠ 0

tactic: rw [ZeroHom.map_zero, ZeroHom.map_zero]
state_before: case h.refine'_2
R : Type ?u.598712
n : ℕ
⊢ ↑(μ * ↑ζ) 0 = ↑1 0

tactic: simp
state_before: case h.refine'_3
R : Type ?u.598712
n : ℕ
⊢ ↑(μ * ↑ζ) 1 = ↑1 1

tactic: intro a b _ha _hb hab ha' hb'
state_before: case h.refine'_4
R : Type ?u.598712
n : ℕ
⊢ ∀ (a b : ℕ), 1 < a → 1 < b → coprime a b → ↑(μ * ↑ζ) a = ↑1 a → ↑(μ * ↑ζ) b = ↑1 b → ↑(μ * ↑ζ) (a * b) = ↑1 (a * b)

tactic: rw [IsMultiplicative.map_mul_of_coprime _ hab, ha', hb',
  IsMultiplicative.map_mul_of_coprime isMultiplicative_one hab]
state_before: case h.refine'_4
R : Type ?u.598712
n a b : ℕ
_ha : 1 < a
_hb : 1 < b
hab : coprime a b
ha' : ↑(μ * ↑ζ) a = ↑1 a
hb' : ↑(μ * ↑ζ) b = ↑1 b
⊢ ↑(μ * ↑ζ) (a * b) = ↑1 (a * b)

tactic: exact isMultiplicative_moebius.mul isMultiplicative_zeta.nat_cast
state_before: R : Type ?u.598712
n a b : ℕ
_ha : 1 < a
_hb : 1 < b
hab : coprime a b
ha' : ↑(μ * ↑ζ) a = ↑1 a
hb' : ↑(μ * ↑ζ) b = ↑1 b
⊢ IsMultiplicative (μ * ↑ζ)
Theorem: reflTransGen_of_succ_of_le
File: Mathlib/Order/SuccPred/Relation.lean

tactic: revert h
state_before: α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
r : α → α → Prop
n m : α
h : ∀ (i : α), i ∈ Ico n m → r i (succ i)
hnm : n ≤ m
⊢ ReflTransGen r n m

tactic: refine' Succ.rec _ _ hnm
state_before: α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
r : α → α → Prop
n m : α
hnm : n ≤ m
⊢ (∀ (i : α), i ∈ Ico n m → r i (succ i)) → ReflTransGen r n m

tactic: intro _
state_before: case refine'_1
α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
r : α → α → Prop
n m : α
hnm : n ≤ m
⊢ (∀ (i : α), i ∈ Ico n n → r i (succ i)) → ReflTransGen r n n

tactic: exact ReflTransGen.refl
state_before: case refine'_1
α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
r : α → α → Prop
n m : α
hnm : n ≤ m
h✝ : ∀ (i : α), i ∈ Ico n n → r i (succ i)
⊢ ReflTransGen r n n

tactic: intro m hnm ih h
state_before: case refine'_2
α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
r : α → α → Prop
n m : α
hnm : n ≤ m
⊢ ∀ (n_1 : α),
    n ≤ n_1 →
      ((∀ (i : α), i ∈ Ico n n_1 → r i (succ i)) → ReflTransGen r n n_1) →
        (∀ (i : α), i ∈ Ico n (succ n_1) → r i (succ i)) → ReflTransGen r n (succ n_1)

tactic: have : ReflTransGen r n m := ih fun i hi => h i ⟨hi.1, hi.2.trans_le <| le_succ m⟩
state_before: case refine'_2
α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
r : α → α → Prop
n m✝ : α
hnm✝ : n ≤ m✝
m : α
hnm : n ≤ m
ih : (∀ (i : α), i ∈ Ico n m → r i (succ i)) → ReflTransGen r n m
h : ∀ (i : α), i ∈ Ico n (succ m) → r i (succ i)
⊢ ReflTransGen r n (succ m)

tactic: cases' (le_succ m).eq_or_lt with hm hm
state_before: case refine'_2
α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
r : α → α → Prop
n m✝ : α
hnm✝ : n ≤ m✝
m : α
hnm : n ≤ m
ih : (∀ (i : α), i ∈ Ico n m → r i (succ i)) → ReflTransGen r n m
h : ∀ (i : α), i ∈ Ico n (succ m) → r i (succ i)
this : ReflTransGen r n m
⊢ ReflTransGen r n (succ m)

tactic: exact this.tail (h m ⟨hnm, hm⟩)
state_before: case refine'_2.inr
α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
r : α → α → Prop
n m✝ : α
hnm✝ : n ≤ m✝
m : α
hnm : n ≤ m
ih : (∀ (i : α), i ∈ Ico n m → r i (succ i)) → ReflTransGen r n m
h : ∀ (i : α), i ∈ Ico n (succ m) → r i (succ i)
this : ReflTransGen r n m
hm : m < succ m
⊢ ReflTransGen r n (succ m)

tactic: rwa [← hm]
state_before: case refine'_2.inl
α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
r : α → α → Prop
n m✝ : α
hnm✝ : n ≤ m✝
m : α
hnm : n ≤ m
ih : (∀ (i : α), i ∈ Ico n m → r i (succ i)) → ReflTransGen r n m
h : ∀ (i : α), i ∈ Ico n (succ m) → r i (succ i)
this : ReflTransGen r n m
hm : m = succ m
⊢ ReflTransGen r n (succ m)
Theorem: Matrix.mul_invOf_mul_self_cancel
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: rw [Matrix.mul_assoc, Matrix.invOf_mul_self, Matrix.mul_one]
state_before: l : Type ?u.13040
m : Type u
n : Type u'
α : Type v
inst✝³ : Fintype n
inst✝² : DecidableEq n
inst✝¹ : CommRing α
A : Matrix m n α
B : Matrix n n α
inst✝ : Invertible B
⊢ A ⬝ ⅟B ⬝ B = A
Theorem: AddCircle.norm_neg_period
File: Mathlib/Analysis/Normed/Group/AddCircle.lean

tactic: suffices ‖(↑(-1 * x) : AddCircle (-1 * p))‖ = ‖(x : AddCircle p)‖ by
  rw [← this, neg_one_mul]
  simp
state_before: p x : ℝ
⊢ ‖↑x‖ = ‖↑x‖

tactic: simp only [norm_coe_mul, abs_neg, abs_one, one_mul]
state_before: p x : ℝ
⊢ ‖↑(-1 * x)‖ = ‖↑x‖

tactic: rw [← this, neg_one_mul]
state_before: p x : ℝ
this : ‖↑(-1 * x)‖ = ‖↑x‖
⊢ ‖↑x‖ = ‖↑x‖

tactic: simp
state_before: p x : ℝ
this : ‖↑(-1 * x)‖ = ‖↑x‖
⊢ ‖↑x‖ = ‖↑(-1 * x)‖
Theorem: Submodule.isClosed_or_dense_of_isCoatom
File: Mathlib/Topology/Algebra/Module/Basic.lean

tactic: refine (hs.le_iff.mp s.le_topologicalClosure).symm.imp ?_ dense_iff_topologicalClosure_eq_top.mpr
state_before: R R' : Type u
M M' : Type v
inst✝¹⁰ : Semiring R
inst✝⁹ : Ring R'
inst✝⁸ : TopologicalSpace M
inst✝⁷ : AddCommMonoid M
inst✝⁶ : TopologicalSpace M'
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M
inst✝³ : ContinuousConstSMul R M
inst✝² : Module R' M'
inst✝¹ : ContinuousConstSMul R' M'
inst✝ : ContinuousAdd M
s : Submodule R M
hs : IsCoatom s
⊢ IsClosed ↑s ∨ Dense ↑s

tactic: exact fun h ↦ h ▸ isClosed_closure
state_before: R R' : Type u
M M' : Type v
inst✝¹⁰ : Semiring R
inst✝⁹ : Ring R'
inst✝⁸ : TopologicalSpace M
inst✝⁷ : AddCommMonoid M
inst✝⁶ : TopologicalSpace M'
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M
inst✝³ : ContinuousConstSMul R M
inst✝² : Module R' M'
inst✝¹ : ContinuousConstSMul R' M'
inst✝ : ContinuousAdd M
s : Submodule R M
hs : IsCoatom s
⊢ topologicalClosure s = s → IsClosed ↑s
Theorem: CompositionAsSet.boundary_zero
File: Mathlib/Combinatorics/Composition.lean

tactic: rw [boundary, Finset.orderEmbOfFin_zero rfl c.card_boundaries_pos]
state_before: n : ℕ
c : CompositionAsSet n
⊢ ↑(boundary c) { val := 0, isLt := (_ : 0 < Finset.card c.boundaries) } = 0

tactic: exact le_antisymm (Finset.min'_le _ _ c.zero_mem) (Fin.zero_le _)
state_before: n : ℕ
c : CompositionAsSet n
⊢ Finset.min' c.boundaries (_ : Finset.Nonempty c.boundaries) = 0
Theorem: MonoidAlgebra.mem_adjoin_support
File: Mathlib/RingTheory/FiniteType.lean

tactic: suffices span R (of R M '' f.support) ≤ Subalgebra.toSubmodule (adjoin R (of R M '' f.support)) by
  exact this (mem_span_support f)
state_before: R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
inst✝ : Monoid M
f : MonoidAlgebra R M
⊢ f ∈ adjoin R (↑(of R M) '' ↑f.support)

tactic: rw [Submodule.span_le]
state_before: R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
inst✝ : Monoid M
f : MonoidAlgebra R M
⊢ span R (↑(of R M) '' ↑f.support) ≤ ↑Subalgebra.toSubmodule (adjoin R (↑(of R M) '' ↑f.support))

tactic: exact subset_adjoin
state_before: R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
inst✝ : Monoid M
f : MonoidAlgebra R M
⊢ ↑(of R M) '' ↑f.support ⊆ ↑(↑Subalgebra.toSubmodule (adjoin R (↑(of R M) '' ↑f.support)))

tactic: exact this (mem_span_support f)
state_before: R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
inst✝ : Monoid M
f : MonoidAlgebra R M
this : span R (↑(of R M) '' ↑f.support) ≤ ↑Subalgebra.toSubmodule (adjoin R (↑(of R M) '' ↑f.support))
⊢ f ∈ adjoin R (↑(of R M) '' ↑f.support)
Theorem: CategoryTheory.Limits.MulticospanIndex.sndPiMap_π
File: Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean

tactic: simp [sndPiMap]
state_before: C : Type u
inst✝² : Category C
I : MulticospanIndex C
inst✝¹ : HasProduct I.left
inst✝ : HasProduct I.right
b : I.R
⊢ sndPiMap I ≫ Pi.π I.right b = Pi.π I.left (sndTo I b) ≫ snd I b
Theorem: List.iota_eq_iotaTR
File: src/lean/Init/Data/List/Basic.lean

tactic: induction n generalizing r with
| zero => simp [iota, iotaTR.go]
| succ n ih => simp [iota, iotaTR.go, ih, append_assoc]
state_before: α : Type u
β : Type v
γ : Type w
n : Nat
r : List Nat
⊢ iotaTR.go n r = reverse r ++ iota n

tactic: simp [iota, iotaTR.go]
state_before: case zero
α : Type u
β : Type v
γ : Type w
r : List Nat
⊢ iotaTR.go Nat.zero r = reverse r ++ iota Nat.zero

tactic: simp [iota, iotaTR.go, ih, append_assoc]
state_before: case succ
α : Type u
β : Type v
γ : Type w
n : Nat
ih : ∀ (r : List Nat), iotaTR.go n r = reverse r ++ iota n
r : List Nat
⊢ iotaTR.go (Nat.succ n) r = reverse r ++ iota (Nat.succ n)

tactic: simp [iotaTR, aux]
state_before: α : Type u
β : Type v
γ : Type w
aux : ∀ (n : Nat) (r : List Nat), iotaTR.go n r = reverse r ++ iota n
n : Nat
⊢ iota n = iotaTR n
Theorem: LinearMap.ker_pi
File: Mathlib/LinearAlgebra/Pi.lean

tactic: ext c
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
ι' : Type x'
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : Module R M₂
inst✝³ : AddCommMonoid M₃
inst✝² : Module R M₃
φ : ι → Type i
inst✝¹ : (i : ι) → AddCommMonoid (φ i)
inst✝ : (i : ι) → Module R (φ i)
f : (i : ι) → M₂ →ₗ[R] φ i
⊢ ker (pi f) = ⨅ (i : ι), ker (f i)

tactic: simp [funext_iff]
state_before: case h
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
ι' : Type x'
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : Module R M₂
inst✝³ : AddCommMonoid M₃
inst✝² : Module R M₃
φ : ι → Type i
inst✝¹ : (i : ι) → AddCommMonoid (φ i)
inst✝ : (i : ι) → Module R (φ i)
f : (i : ι) → M₂ →ₗ[R] φ i
c : M₂
⊢ c ∈ ker (pi f) ↔ c ∈ ⨅ (i : ι), ker (f i)
Theorem: Int.fract_eq_fract
File: Mathlib/Algebra/Order/Floor.lean

tactic: unfold fract at h
state_before: F : Type ?u.164824
α : Type u_1
β : Type ?u.164830
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
h : fract a = fract b
⊢ a - b = ↑(⌊a⌋ - ⌊b⌋)

tactic: rw [Int.cast_sub, sub_eq_sub_iff_sub_eq_sub.1 h]
state_before: F : Type ?u.164824
α : Type u_1
β : Type ?u.164830
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
h : a - ↑⌊a⌋ = b - ↑⌊b⌋
⊢ a - b = ↑(⌊a⌋ - ⌊b⌋)

tactic: rintro ⟨z, hz⟩
state_before: F : Type ?u.164824
α : Type u_1
β : Type ?u.164830
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
⊢ (∃ z, a - b = ↑z) → fract a = fract b

tactic: refine' fract_eq_iff.2 ⟨fract_nonneg _, fract_lt_one _, z + ⌊b⌋, _⟩
state_before: case intro
F : Type ?u.164824
α : Type u_1
β : Type ?u.164830
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z✝ : ℤ
a✝ a b : α
z : ℤ
hz : a - b = ↑z
⊢ fract a = fract b

tactic: rw [eq_add_of_sub_eq hz, add_comm, Int.cast_add]
state_before: case intro
F : Type ?u.164824
α : Type u_1
β : Type ?u.164830
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z✝ : ℤ
a✝ a b : α
z : ℤ
hz : a - b = ↑z
⊢ a - fract b = ↑(z + ⌊b⌋)

tactic: exact add_sub_sub_cancel _ _ _
state_before: case intro
F : Type ?u.164824
α : Type u_1
β : Type ?u.164830
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z✝ : ℤ
a✝ a b : α
z : ℤ
hz : a - b = ↑z
⊢ b + ↑z - fract b = ↑z + ↑⌊b⌋
Theorem: FreeGroup.Red.Step.append_left_iff
File: Mathlib/GroupTheory/FreeGroup.lean

tactic: simp
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
⊢ Step ([] ++ L₁) ([] ++ L₂) ↔ Step L₁ L₂

tactic: simp [Step.append_left_iff l, Step.cons_cons_iff]
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
p : α × Bool
l : List (α × Bool)
⊢ Step (p :: l ++ L₁) (p :: l ++ L₂) ↔ Step L₁ L₂
Theorem: Module.Baer.chain_linearPMap_of_chain_extensionOf
File: Mathlib/Algebra/Module/Injective.lean

tactic: rintro _ ⟨a, a_mem, rfl⟩ _ ⟨b, b_mem, rfl⟩ neq
state_before: R : Type u
inst✝⁶ : Ring R
Q : TypeMax
inst✝⁵ : AddCommGroup Q
inst✝⁴ : Module R Q
M N : Type (max u v)
inst✝³ : AddCommGroup M
inst✝² : AddCommGroup N
inst✝¹ : Module R M
inst✝ : Module R N
i : M →ₗ[R] N
f : M →ₗ[R] Q
c : Set (ExtensionOf i f)
hchain : IsChain (fun x x_1 => x ≤ x_1) c
⊢ IsChain (fun x x_1 => x ≤ x_1) ((fun x => x.toLinearPMap) '' c)

tactic: exact hchain a_mem b_mem (ne_of_apply_ne _ neq)
state_before: case intro.intro.intro.intro
R : Type u
inst✝⁶ : Ring R
Q : TypeMax
inst✝⁵ : AddCommGroup Q
inst✝⁴ : Module R Q
M N : Type (max u v)
inst✝³ : AddCommGroup M
inst✝² : AddCommGroup N
inst✝¹ : Module R M
inst✝ : Module R N
i : M →ₗ[R] N
f : M →ₗ[R] Q
c : Set (ExtensionOf i f)
hchain : IsChain (fun x x_1 => x ≤ x_1) c
a : ExtensionOf i f
a_mem : a ∈ c
b : ExtensionOf i f
b_mem : b ∈ c
neq : (fun x => x.toLinearPMap) a ≠ (fun x => x.toLinearPMap) b
⊢ (fun x x_1 => x ≤ x_1) ((fun x => x.toLinearPMap) a) ((fun x => x.toLinearPMap) b) ∨
    (fun x x_1 => x ≤ x_1) ((fun x => x.toLinearPMap) b) ((fun x => x.toLinearPMap) a)
Theorem: Metric.cthickening_eq_iInter_thickening''
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: rw [← cthickening_max_zero, cthickening_eq_iInter_thickening]
state_before: ι : Sort ?u.143302
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s t : Set α
x : α
δ : ℝ
E : Set α
⊢ cthickening δ E = ⋂ (ε : ℝ) (_ : max 0 δ < ε), thickening ε E

tactic: exact le_max_left _ _
state_before: case δ_nn
ι : Sort ?u.143302
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s t : Set α
x : α
δ : ℝ
E : Set α
⊢ 0 ≤ max 0 δ
Theorem: NNReal.tendsto_const_div_atTop_nhds_0_nat
File: Mathlib/Analysis/SpecificLimits/Basic.lean

tactic: simpa using tendsto_const_nhds.mul NNReal.tendsto_inverse_atTop_nhds_0_nat
state_before: α : Type ?u.1738
β : Type ?u.1741
ι : Type ?u.1744
C : ℝ≥0
⊢ Tendsto (fun n => C / ↑n) atTop (𝓝 0)
Theorem: AlgebraicGeometry.RingedSpace.basicOpen_res_eq
File: Mathlib/AlgebraicGeometry/RingedSpace.lean

tactic: apply le_antisymm
state_before: X : RingedSpace
U V : (Opens ↑↑X.toPresheafedSpace)ᵒᵖ
i : U ⟶ V
inst✝ : IsIso i
f : ↑(X.presheaf.obj U)
⊢ basicOpen X (↑(X.presheaf.map i) f) = basicOpen X f

tactic: rw [X.basicOpen_res i f]
state_before: case a
X : RingedSpace
U V : (Opens ↑↑X.toPresheafedSpace)ᵒᵖ
i : U ⟶ V
inst✝ : IsIso i
f : ↑(X.presheaf.obj U)
⊢ basicOpen X (↑(X.presheaf.map i) f) ≤ basicOpen X f

tactic: exact inf_le_right
state_before: case a
X : RingedSpace
U V : (Opens ↑↑X.toPresheafedSpace)ᵒᵖ
i : U ⟶ V
inst✝ : IsIso i
f : ↑(X.presheaf.obj U)
⊢ V.unop ⊓ basicOpen X f ≤ basicOpen X f

tactic: have : X.basicOpen ((X.presheaf.map _ ≫ X.presheaf.map _) f) = _ :=
  X.basicOpen_res (inv i) (X.presheaf.map i f)
state_before: case a
X : RingedSpace
U V : (Opens ↑↑X.toPresheafedSpace)ᵒᵖ
i : U ⟶ V
inst✝ : IsIso i
f : ↑(X.presheaf.obj U)
⊢ basicOpen X f ≤ basicOpen X (↑(X.presheaf.map i) f)

tactic: rw [← X.presheaf.map_comp, IsIso.hom_inv_id, X.presheaf.map_id] at this
state_before: case a
X : RingedSpace
U V : (Opens ↑↑X.toPresheafedSpace)ᵒᵖ
i : U ⟶ V
inst✝ : IsIso i
f : ↑(X.presheaf.obj U)
this : basicOpen X (↑(X.presheaf.map i ≫ X.presheaf.map (inv i)) f) = U.unop ⊓ basicOpen X (↑(X.presheaf.map i) f)
⊢ basicOpen X f ≤ basicOpen X (↑(X.presheaf.map i) f)

tactic: erw [this]
state_before: case a
X : RingedSpace
U V : (Opens ↑↑X.toPresheafedSpace)ᵒᵖ
i : U ⟶ V
inst✝ : IsIso i
f : ↑(X.presheaf.obj U)
this : basicOpen X (↑(𝟙 (X.presheaf.obj U)) f) = U.unop ⊓ basicOpen X (↑(X.presheaf.map i) f)
⊢ basicOpen X f ≤ basicOpen X (↑(X.presheaf.map i) f)

tactic: exact inf_le_right
state_before: case a
X : RingedSpace
U V : (Opens ↑↑X.toPresheafedSpace)ᵒᵖ
i : U ⟶ V
inst✝ : IsIso i
f : ↑(X.presheaf.obj U)
this : basicOpen X (↑(𝟙 (X.presheaf.obj U)) f) = U.unop ⊓ basicOpen X (↑(X.presheaf.map i) f)
⊢ U.unop ⊓ basicOpen X (↑(X.presheaf.map i) f) ≤ basicOpen X (↑(X.presheaf.map i) f)
Theorem: CategoryTheory.Sieve.pullback_eq_top_iff_mem
File: Mathlib/CategoryTheory/Sites/Sieves.lean

tactic: rw [← id_mem_iff_eq_top, pullback_apply, id_comp]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
X Y Z : C
f✝ : Y ⟶ X
S R : Sieve X
f : Y ⟶ X
⊢ S.arrows f ↔ pullback f S = ⊤
Theorem: Multiset.Ico_self
File: Mathlib/Data/Multiset/LocallyFinite.lean

tactic: rw [Ico, Finset.Ico_self, Finset.empty_val]
state_before: α : Type u_1
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ Ico a a = 0
Theorem: List.forall₂_drop
File: Mathlib/Data/List/Forall2.lean

tactic: simp only [drop, h]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.129991
δ : Type ?u.129994
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
x✝¹ : List α
x✝ : List β
h : Forall₂ R x✝¹ x✝
⊢ Forall₂ R (drop 0 x✝¹) (drop 0 x✝)

tactic: simp only [Forall₂.nil, drop]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.129991
δ : Type ?u.129994
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
n✝ : ℕ
⊢ Forall₂ R (drop (n✝ + 1) []) (drop (n✝ + 1) [])

tactic: simp [And.intro h₁ h₂, forall₂_drop n]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.129991
δ : Type ?u.129994
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
n : ℕ
a✝ : α
b✝ : β
l₁✝ : List α
l₂✝ : List β
h₁ : R a✝ b✝
h₂ : Forall₂ R l₁✝ l₂✝
⊢ Forall₂ R (drop (n + 1) (a✝ :: l₁✝)) (drop (n + 1) (b✝ :: l₂✝))
Theorem: MeasureTheory.prob_compl_eq_zero_iff
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [prob_compl_eq_one_sub hs, tsub_eq_zero_iff_le, one_le_prob_iff]
state_before: α : Type u_1
β : Type ?u.708423
γ : Type ?u.708426
δ : Type ?u.708429
ι : Type ?u.708432
R : Type ?u.708435
R' : Type ?u.708438
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : IsProbabilityMeasure μ
hs : MeasurableSet s
⊢ ↑↑μ (sᶜ) = 0 ↔ ↑↑μ s = 1
Theorem: Ordinal.opow_le_opow_right
File: Mathlib/SetTheory/Ordinal/Exponential.lean

tactic: cases' lt_or_eq_of_le (one_le_iff_pos.2 h₁) with h₁ h₁
state_before: a b c : Ordinal
h₁ : 0 < a
h₂ : b ≤ c
⊢ a ^ b ≤ a ^ c

tactic: exact (opow_le_opow_iff_right h₁).2 h₂
state_before: case inl
a b c : Ordinal
h₁✝ : 0 < a
h₂ : b ≤ c
h₁ : 1 < a
⊢ a ^ b ≤ a ^ c

tactic: subst a
state_before: case inr
a b c : Ordinal
h₁✝ : 0 < a
h₂ : b ≤ c
h₁ : 1 = a
⊢ a ^ b ≤ a ^ c

tactic: simp only [one_opow, le_refl]
state_before: case inr
b c : Ordinal
h₂ : b ≤ c
h₁ : 0 < 1
⊢ 1 ^ b ≤ 1 ^ c
Theorem: Complex.continuous_cosh
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: change Continuous fun z => (exp z + exp (-z)) / 2
state_before: ⊢ Continuous cosh

tactic: continuity
state_before: ⊢ Continuous fun z => (exp z + exp (-z)) / 2