tasksource/leandojo huggingface dataset:
Theorem: Finset.interior_iInter
File: Mathlib/Topology/Basic.lean

tactic: classical
  refine' s.induction_on (by simp) _
  intro i s _ h₂
  simp [h₂]
state_before: α : Type u
β : Type v
ι✝ : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
ι : Type u_1
s : Finset ι
f : ι → Set α
⊢ interior (⋂ (i : ι) (_ : i ∈ s), f i) = ⋂ (i : ι) (_ : i ∈ s), interior (f i)

tactic: refine' s.induction_on (by simp) _
state_before: α : Type u
β : Type v
ι✝ : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
ι : Type u_1
s : Finset ι
f : ι → Set α
⊢ interior (⋂ (i : ι) (_ : i ∈ s), f i) = ⋂ (i : ι) (_ : i ∈ s), interior (f i)

tactic: intro i s _ h₂
state_before: α : Type u
β : Type v
ι✝ : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
ι : Type u_1
s : Finset ι
f : ι → Set α
⊢ ∀ ⦃a : ι⦄ {s : Finset ι},
    ¬a ∈ s →
      (interior (⋂ (i : ι) (_ : i ∈ s), f i) = ⋂ (i : ι) (_ : i ∈ s), interior (f i)) →
        interior (⋂ (i : ι) (_ : i ∈ insert a s), f i) = ⋂ (i : ι) (_ : i ∈ insert a s), interior (f i)

tactic: simp [h₂]
state_before: α : Type u
β : Type v
ι✝ : Sort w
a : α
s✝¹ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
ι : Type u_1
s✝ : Finset ι
f : ι → Set α
i : ι
s : Finset ι
a✝ : ¬i ∈ s
h₂ : interior (⋂ (i : ι) (_ : i ∈ s), f i) = ⋂ (i : ι) (_ : i ∈ s), interior (f i)
⊢ interior (⋂ (i_1 : ι) (_ : i_1 ∈ insert i s), f i_1) = ⋂ (i_1 : ι) (_ : i_1 ∈ insert i s), interior (f i_1)

tactic: simp
state_before: α : Type u
β : Type v
ι✝ : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
ι : Type u_1
s : Finset ι
f : ι → Set α
⊢ interior (⋂ (i : ι) (_ : i ∈ ∅), f i) = ⋂ (i : ι) (_ : i ∈ ∅), interior (f i)
Theorem: SeparationQuotient.continuous_lift₂
File: Mathlib/Topology/Inseparable.lean

tactic: simp only [continuous_iff_continuousOn_univ, continuousOn_lift₂, preimage_univ]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type ?u.113085
ι : Type ?u.113088
π : ι → Type ?u.113093
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x y z : X
s : Set X
f✝ : X → Y
t : Set (SeparationQuotient X)
f : X → Y → Z
hf : ∀ (a : X) (b : Y) (c : X) (d : Y), (a ~ᵢ c) → (b ~ᵢ d) → f a b = f c d
⊢ Continuous (uncurry (lift₂ f hf)) ↔ Continuous (uncurry f)
Theorem: LinearMap.eqOn_span
File: Mathlib/LinearAlgebra/Span.lean

tactic: refine' span_induction h H _ _ _ <;> simp (config := { contextual := true })
state_before: R : Type u_2
R₂ : Type u_3
K : Type ?u.336789
M : Type u_1
M₂ : Type u_4
V : Type ?u.336798
S : Type ?u.336801
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : Semiring R₂
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R₂ M₂
σ₁₂ : R →+* R₂
s : Set M
f g : M →ₛₗ[σ₁₂] M₂
H : Set.EqOn (↑f) (↑g) s
x : M
h : x ∈ span R s
⊢ ↑f x = ↑g x
Theorem: finprod_mem_insert'
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: rw [insert_eq, finprod_mem_union' _ _ hs, finprod_mem_singleton]
state_before: α : Type u_1
β : Type ?u.342023
ι : Type ?u.342026
G : Type ?u.342029
M : Type u_2
N : Type ?u.342035
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a b : α
s t : Set α
f : α → M
h : ¬a ∈ s
hs : Set.Finite (s ∩ mulSupport f)
⊢ (∏ᶠ (i : α) (_ : i ∈ insert a s), f i) = f a * ∏ᶠ (i : α) (_ : i ∈ s), f i

tactic: rwa [disjoint_singleton_left]
state_before: α : Type u_1
β : Type ?u.342023
ι : Type ?u.342026
G : Type ?u.342029
M : Type u_2
N : Type ?u.342035
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a b : α
s t : Set α
f : α → M
h : ¬a ∈ s
hs : Set.Finite (s ∩ mulSupport f)
⊢ Disjoint {a} s

tactic: exact (finite_singleton a).inter_of_left _
state_before: α : Type u_1
β : Type ?u.342023
ι : Type ?u.342026
G : Type ?u.342029
M : Type u_2
N : Type ?u.342035
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a b : α
s t : Set α
f : α → M
h : ¬a ∈ s
hs : Set.Finite (s ∩ mulSupport f)
⊢ Set.Finite ({a} ∩ mulSupport f)
Theorem: Submodule.sub_mem_iff_right
File: Mathlib/Algebra/Module/Submodule/Basic.lean

tactic: rw [sub_eq_add_neg, p.add_mem_iff_right hx, p.neg_mem_iff]
state_before: G : Type u''
S : Type u'
R : Type u
M : Type v
ι : Type w
inst✝¹ : Ring R
inst✝ : AddCommGroup M
module_M : Module R M
p p' : Submodule R M
r : R
x y : M
hx : x ∈ p
⊢ x - y ∈ p ↔ y ∈ p
Theorem: Set.preimage_mul_left_one
File: Mathlib/Data/Set/Pointwise/Basic.lean

tactic: rw [← image_mul_left', image_one, mul_one]
state_before: F : Type ?u.130016
α : Type u_1
β : Type ?u.130022
γ : Type ?u.130025
inst✝ : Group α
s t : Set α
a b : α
⊢ (fun x x_1 => x * x_1) a ⁻¹' 1 = {a⁻¹}
Theorem: IsIntegralClosure.noZeroSMulDivisors
File: Mathlib/RingTheory/IntegralClosure.lean

tactic: refine'
  Function.Injective.noZeroSMulDivisors _ (IsIntegralClosure.algebraMap_injective A R B)
    (map_zero _) fun _ _ => _
state_before: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : CommRing B
inst✝⁵ : Algebra R B
inst✝⁴ : Algebra A B
inst✝³ : IsIntegralClosure A R B
inst✝² : Algebra R A
inst✝¹ : IsScalarTower R A B
inst✝ : NoZeroSMulDivisors R B
⊢ NoZeroSMulDivisors R A

tactic: simp only [Algebra.algebraMap_eq_smul_one, IsScalarTower.smul_assoc]
state_before: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : CommRing B
inst✝⁵ : Algebra R B
inst✝⁴ : Algebra A B
inst✝³ : IsIntegralClosure A R B
inst✝² : Algebra R A
inst✝¹ : IsScalarTower R A B
inst✝ : NoZeroSMulDivisors R B
x✝¹ : R
x✝ : A
⊢ ↑(algebraMap A B) (x✝¹ • x✝) = x✝¹ • ↑(algebraMap A B) x✝
Theorem: ModuleCat.cokernel_π_ext
File: Mathlib/Algebra/Category/ModuleCat/Kernels.lean

tactic: subst w
state_before: R : Type u
inst✝ : Ring R
G H : ModuleCat R
f✝ : G ⟶ H
M N : ModuleCat R
f : M ⟶ N
x y : ↑N
m : ↑M
w : x = y + ↑f m
⊢ ↑(cokernel.π f) x = ↑(cokernel.π f) y

tactic: simpa only [map_add, add_right_eq_self] using cokernel.condition_apply f m
state_before: R : Type u
inst✝ : Ring R
G H : ModuleCat R
f✝ : G ⟶ H
M N : ModuleCat R
f : M ⟶ N
y : ↑N
m : ↑M
⊢ ↑(cokernel.π f) (y + ↑f m) = ↑(cokernel.π f) y
Theorem: Ordering.compares_iff_of_compares_impl
File: Mathlib/Order/Compare.lean

tactic: refine' ⟨h, fun ho => _⟩
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : Preorder β
a b : α
a' b' : β
h : ∀ {o : Ordering}, Compares o a b → Compares o a' b'
o : Ordering
⊢ Compares o a b ↔ Compares o a' b'

tactic: cases' lt_trichotomy a b with hab hab
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : Preorder β
a b : α
a' b' : β
h : ∀ {o : Ordering}, Compares o a b → Compares o a' b'
o : Ordering
ho : Compares o a' b'
⊢ Compares o a b

tactic: have hab : Compares Ordering.lt a b := hab
state_before: case inl
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : Preorder β
a b : α
a' b' : β
h : ∀ {o : Ordering}, Compares o a b → Compares o a' b'
o : Ordering
ho : Compares o a' b'
hab : a < b
⊢ Compares o a b

tactic: rwa [ho.inj (h hab)]
state_before: case inl
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : Preorder β
a b : α
a' b' : β
h : ∀ {o : Ordering}, Compares o a b → Compares o a' b'
o : Ordering
ho : Compares o a' b'
hab✝ : a < b
hab : Compares lt a b
⊢ Compares o a b

tactic: cases' hab with hab hab
state_before: case inr
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : Preorder β
a b : α
a' b' : β
h : ∀ {o : Ordering}, Compares o a b → Compares o a' b'
o : Ordering
ho : Compares o a' b'
hab : a = b ∨ b < a
⊢ Compares o a b

tactic: have hab : Compares Ordering.eq a b := hab
state_before: case inr.inl
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : Preorder β
a b : α
a' b' : β
h : ∀ {o : Ordering}, Compares o a b → Compares o a' b'
o : Ordering
ho : Compares o a' b'
hab : a = b
⊢ Compares o a b

tactic: rwa [ho.inj (h hab)]
state_before: case inr.inl
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : Preorder β
a b : α
a' b' : β
h : ∀ {o : Ordering}, Compares o a b → Compares o a' b'
o : Ordering
ho : Compares o a' b'
hab✝ : a = b
hab : Compares eq a b
⊢ Compares o a b

tactic: have hab : Compares Ordering.gt a b := hab
state_before: case inr.inr
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : Preorder β
a b : α
a' b' : β
h : ∀ {o : Ordering}, Compares o a b → Compares o a' b'
o : Ordering
ho : Compares o a' b'
hab : b < a
⊢ Compares o a b

tactic: rwa [ho.inj (h hab)]
state_before: case inr.inr
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : Preorder β
a b : α
a' b' : β
h : ∀ {o : Ordering}, Compares o a b → Compares o a' b'
o : Ordering
ho : Compares o a' b'
hab✝ : b < a
hab : Compares gt a b
⊢ Compares o a b
Theorem: taylorWithin_succ
File: Mathlib/Analysis/Calculus/Taylor.lean

tactic: dsimp only [taylorWithin]
state_before: 𝕜 : Type ?u.66235
E : Type u_1
F : Type ?u.66241
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ → E
n : ℕ
s : Set ℝ
x₀ : ℝ
⊢ taylorWithin f (n + 1) s x₀ =
    taylorWithin f n s x₀ +
      ↑(PolynomialModule.comp (Polynomial.X - ↑Polynomial.C x₀))
        (↑(PolynomialModule.single ℝ (n + 1)) (taylorCoeffWithin f (n + 1) s x₀))

tactic: rw [Finset.sum_range_succ]
state_before: 𝕜 : Type ?u.66235
E : Type u_1
F : Type ?u.66241
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ → E
n : ℕ
s : Set ℝ
x₀ : ℝ
⊢ ∑ k in Finset.range (n + 1 + 1),
      ↑(PolynomialModule.comp (Polynomial.X - ↑Polynomial.C x₀))
        (↑(PolynomialModule.single ℝ k) (taylorCoeffWithin f k s x₀)) =
    ∑ k in Finset.range (n + 1),
        ↑(PolynomialModule.comp (Polynomial.X - ↑Polynomial.C x₀))
          (↑(PolynomialModule.single ℝ k) (taylorCoeffWithin f k s x₀)) +
      ↑(PolynomialModule.comp (Polynomial.X - ↑Polynomial.C x₀))
        (↑(PolynomialModule.single ℝ (n + 1)) (taylorCoeffWithin f (n + 1) s x₀))
Theorem: Stream'.WSeq.dropn_ofSeq
File: Mathlib/Data/Seq/WSeq.lean

tactic: simp only [drop, Nat.add_eq, add_zero, Seq.drop]
state_before: α : Type u
β : Type v
γ : Type w
s : Seq α
n : ℕ
⊢ drop (↑s) (n + 1) = ↑(Seq.drop s (n + 1))

tactic: rw [dropn_ofSeq s n, tail_ofSeq]
state_before: α : Type u
β : Type v
γ : Type w
s : Seq α
n : ℕ
⊢ tail (drop (↑s) n) = ↑(Seq.tail (Seq.drop s n))
Theorem: MeasureTheory.integrable_smul_measure
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: simpa only [smul_smul, ENNReal.inv_mul_cancel h₁ h₂, one_smul] using
  h.smul_measure (ENNReal.inv_ne_top.2 h₁)
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.848051
δ : Type ?u.848054
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
c : ℝ≥0∞
h₁ : c ≠ 0
h₂ : c ≠ ⊤
h : Integrable f
⊢ Integrable f
Theorem: multiplicity.pow'
File: Mathlib/RingTheory/Multiplicity.lean

tactic: intro k
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p a : α
hp : Prime p
ha : Finite p a
⊢ ∀ {k : ℕ}, Part.get (multiplicity p (a ^ k)) (_ : Finite p (a ^ k)) = k * Part.get (multiplicity p a) ha

tactic: induction' k with k hk
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p a : α
hp : Prime p
ha : Finite p a
k : ℕ
⊢ Part.get (multiplicity p (a ^ k)) (_ : Finite p (a ^ k)) = k * Part.get (multiplicity p a) ha

tactic: simp [one_right hp.not_unit]
state_before: case zero
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p a : α
hp : Prime p
ha : Finite p a
⊢ Part.get (multiplicity p (a ^ zero)) (_ : Finite p (a ^ zero)) = zero * Part.get (multiplicity p a) ha

tactic: have : multiplicity p (a ^ (k + 1)) = multiplicity p (a * a ^ k) := by rw [_root_.pow_succ]
state_before: case succ
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p a : α
hp : Prime p
ha : Finite p a
k : ℕ
hk : Part.get (multiplicity p (a ^ k)) (_ : Finite p (a ^ k)) = k * Part.get (multiplicity p a) ha
⊢ Part.get (multiplicity p (a ^ succ k)) (_ : Finite p (a ^ succ k)) = succ k * Part.get (multiplicity p a) ha

tactic: rw [succ_eq_add_one, get_eq_get_of_eq _ _ this,
  multiplicity.mul' hp, hk, add_mul, one_mul, add_comm]
state_before: case succ
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p a : α
hp : Prime p
ha : Finite p a
k : ℕ
hk : Part.get (multiplicity p (a ^ k)) (_ : Finite p (a ^ k)) = k * Part.get (multiplicity p a) ha
this : multiplicity p (a ^ (k + 1)) = multiplicity p (a * a ^ k)
⊢ Part.get (multiplicity p (a ^ succ k)) (_ : Finite p (a ^ succ k)) = succ k * Part.get (multiplicity p a) ha

tactic: rw [_root_.pow_succ]
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p a : α
hp : Prime p
ha : Finite p a
k : ℕ
hk : Part.get (multiplicity p (a ^ k)) (_ : Finite p (a ^ k)) = k * Part.get (multiplicity p a) ha
⊢ multiplicity p (a ^ (k + 1)) = multiplicity p (a * a ^ k)
Theorem: LinearMap.iterate_injective
File: Mathlib/LinearAlgebra/Basic.lean

tactic: rw [iterate_succ]
state_before: R : Type u_2
R₁ : Type ?u.187673
R₂ : Type ?u.187676
R₃ : Type ?u.187679
R₄ : Type ?u.187682
S : Type ?u.187685
K : Type ?u.187688
K₂ : Type ?u.187691
M : Type u_1
M' : Type ?u.187697
M₁ : Type ?u.187700
M₂ : Type ?u.187703
M₃ : Type ?u.187706
M₄ : Type ?u.187709
N : Type ?u.187712
N₂ : Type ?u.187715
ι : Type ?u.187718
V : Type ?u.187721
V₂ : Type ?u.187724
inst✝¹⁷ : Semiring R
inst✝¹⁶ : Semiring R₂
inst✝¹⁵ : Semiring R₃
inst✝¹⁴ : Semiring R₄
inst✝¹³ : AddCommMonoid M
inst✝¹² : AddCommMonoid M₁
inst✝¹¹ : AddCommMonoid M₂
inst✝¹⁰ : AddCommMonoid M₃
inst✝⁹ : AddCommMonoid M₄
inst✝⁸ : Module R M
inst✝⁷ : Module R M₁
inst✝⁶ : Module R₂ M₂
inst✝⁵ : Module R₃ M₃
inst✝⁴ : Module R₄ M₄
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₃₄ : R₃ →+* R₄
σ₁₃ : R →+* R₃
σ₂₄ : R₂ →+* R₄
σ₁₄ : R →+* R₄
inst✝³ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝² : RingHomCompTriple σ₂₃ σ₃₄ σ₂₄
inst✝¹ : RingHomCompTriple σ₁₃ σ₃₄ σ₁₄
inst✝ : RingHomCompTriple σ₁₂ σ₂₄ σ₁₄
f : M →ₛₗ[σ₁₂] M₂
g : M₂ →ₛₗ[σ₂₃] M₃
f' : M →ₗ[R] M
h : Injective ↑f'
n : ℕ
⊢ Injective ↑(f' ^ (n + 1))

tactic: exact (iterate_injective h n).comp h
state_before: R : Type u_2
R₁ : Type ?u.187673
R₂ : Type ?u.187676
R₃ : Type ?u.187679
R₄ : Type ?u.187682
S : Type ?u.187685
K : Type ?u.187688
K₂ : Type ?u.187691
M : Type u_1
M' : Type ?u.187697
M₁ : Type ?u.187700
M₂ : Type ?u.187703
M₃ : Type ?u.187706
M₄ : Type ?u.187709
N : Type ?u.187712
N₂ : Type ?u.187715
ι : Type ?u.187718
V : Type ?u.187721
V₂ : Type ?u.187724
inst✝¹⁷ : Semiring R
inst✝¹⁶ : Semiring R₂
inst✝¹⁵ : Semiring R₃
inst✝¹⁴ : Semiring R₄
inst✝¹³ : AddCommMonoid M
inst✝¹² : AddCommMonoid M₁
inst✝¹¹ : AddCommMonoid M₂
inst✝¹⁰ : AddCommMonoid M₃
inst✝⁹ : AddCommMonoid M₄
inst✝⁸ : Module R M
inst✝⁷ : Module R M₁
inst✝⁶ : Module R₂ M₂
inst✝⁵ : Module R₃ M₃
inst✝⁴ : Module R₄ M₄
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₃₄ : R₃ →+* R₄
σ₁₃ : R →+* R₃
σ₂₄ : R₂ →+* R₄
σ₁₄ : R →+* R₄
inst✝³ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝² : RingHomCompTriple σ₂₃ σ₃₄ σ₂₄
inst✝¹ : RingHomCompTriple σ₁₃ σ₃₄ σ₁₄
inst✝ : RingHomCompTriple σ₁₂ σ₂₄ σ₁₄
f : M →ₛₗ[σ₁₂] M₂
g : M₂ →ₛₗ[σ₂₃] M₃
f' : M →ₗ[R] M
h : Injective ↑f'
n : ℕ
⊢ Injective ↑(comp (f' ^ n) f')
Theorem: Ordinal.opow_lt_opow_left_of_succ
File: Mathlib/SetTheory/Ordinal/Exponential.lean

tactic: rw [opow_succ, opow_succ]
state_before: a b c : Ordinal
ab : a < b
⊢ a ^ succ c < b ^ succ c

tactic: exact
  (mul_le_mul_right' (opow_le_opow_left c ab.le) a).trans_lt
    (mul_lt_mul_of_pos_left ab (opow_pos c ((Ordinal.zero_le a).trans_lt ab)))
state_before: a b c : Ordinal
ab : a < b
⊢ a ^ c * a < b ^ c * b
Theorem: Int.fract_sub_int
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [fract]
state_before: F : Type ?u.147946
α : Type u_1
β : Type ?u.147952
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a : α
m : ℤ
⊢ fract (a - ↑m) = fract a

tactic: simp
state_before: F : Type ?u.147946
α : Type u_1
β : Type ?u.147952
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a : α
m : ℤ
⊢ a - ↑m - ↑⌊a - ↑m⌋ = fract a
Theorem: midpoint_neg_self
File: Mathlib/LinearAlgebra/AffineSpace/Midpoint.lean

tactic: simpa using midpoint_self_neg R (-x)
state_before: R : Type u_2
V : Type u_1
V' : Type ?u.135249
P : Type ?u.135252
P' : Type ?u.135255
inst✝⁷ : Ring R
inst✝⁶ : Invertible 2
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x✝ y z : P
x : V
⊢ midpoint R (-x) x = 0
Theorem: Real.le_rpow_add
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rcases le_iff_eq_or_lt.1 hx with (H | pos)
state_before: x✝ y✝ z✝ x : ℝ
hx : 0 ≤ x
y z : ℝ
⊢ x ^ y * x ^ z ≤ x ^ (y + z)

tactic: by_cases h : y + z = 0
state_before: case inl
x✝ y✝ z✝ x : ℝ
hx : 0 ≤ x
y z : ℝ
H : 0 = x
⊢ x ^ y * x ^ z ≤ x ^ (y + z)

tactic: simp only [H.symm, h, rpow_zero]
state_before: case pos
x✝ y✝ z✝ x : ℝ
hx : 0 ≤ x
y z : ℝ
H : 0 = x
h : y + z = 0
⊢ x ^ y * x ^ z ≤ x ^ (y + z)

tactic: calc
  (0 : ℝ) ^ y * 0 ^ z ≤ 1 * 1 :=
    mul_le_mul (zero_rpow_le_one y) (zero_rpow_le_one z) (zero_rpow_nonneg z) zero_le_one
  _ = 1 := by simp
state_before: case pos
x✝ y✝ z✝ x : ℝ
hx : 0 ≤ x
y z : ℝ
H : 0 = x
h : y + z = 0
⊢ 0 ^ y * 0 ^ z ≤ 1

tactic: simp
state_before: x✝ y✝ z✝ x : ℝ
hx : 0 ≤ x
y z : ℝ
H : 0 = x
h : y + z = 0
⊢ 1 * 1 = 1

tactic: simp [rpow_add', ← H, h]
state_before: case neg
x✝ y✝ z✝ x : ℝ
hx : 0 ≤ x
y z : ℝ
H : 0 = x
h : ¬y + z = 0
⊢ x ^ y * x ^ z ≤ x ^ (y + z)

tactic: simp [rpow_add pos]
state_before: case inr
x✝ y✝ z✝ x : ℝ
hx : 0 ≤ x
y z : ℝ
pos : 0 < x
⊢ x ^ y * x ^ z ≤ x ^ (y + z)
Theorem: Set.not_unbounded_iff
File: Mathlib/Order/RelClasses.lean

tactic: rw [not_iff_comm, not_bounded_iff]
state_before: α : Type u
β : Type v
r✝ : α → α → Prop
s✝ : β → β → Prop
r : α → α → Prop
s : Set α
⊢ ¬Unbounded r s ↔ Bounded r s
Theorem: FreeAbelianGroup.of_mul_of
File: Mathlib/GroupTheory/FreeAbelianGroup.lean

tactic: rw [mul_def, lift.of, lift.of]
state_before: α : Type u
β : Type v
γ : Type w
inst✝ : Mul α
x y : α
⊢ of x * of y = of (x * y)
Theorem: xor_false
File: Mathlib/Logic/Basic.lean

tactic: ext
state_before: ⊢ Xor' False = id

tactic: simp [Xor']
state_before: case h.a
x✝ : Prop
⊢ Xor' False x✝ ↔ id x✝
Theorem: abs_nsmul
File: Mathlib/Algebra/GroupPower/Lemmas.lean

tactic: cases' le_total a 0 with hneg hpos
state_before: α : Type u_1
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : LinearOrderedAddCommGroup α
a✝ b : α
n : ℕ
a : α
⊢ abs (n • a) = n • abs a

tactic: rw [abs_of_nonpos hneg, ← abs_neg, ← neg_nsmul, abs_of_nonneg]
state_before: case inl
α : Type u_1
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : LinearOrderedAddCommGroup α
a✝ b : α
n : ℕ
a : α
hneg : a ≤ 0
⊢ abs (n • a) = n • abs a

tactic: exact nsmul_nonneg (neg_nonneg.mpr hneg) n
state_before: case inl
α : Type u_1
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : LinearOrderedAddCommGroup α
a✝ b : α
n : ℕ
a : α
hneg : a ≤ 0
⊢ 0 ≤ n • -a

tactic: rw [abs_of_nonneg hpos, abs_of_nonneg]
state_before: case inr
α : Type u_1
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : LinearOrderedAddCommGroup α
a✝ b : α
n : ℕ
a : α
hpos : 0 ≤ a
⊢ abs (n • a) = n • abs a

tactic: exact nsmul_nonneg hpos n
state_before: case inr
α : Type u_1
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : LinearOrderedAddCommGroup α
a✝ b : α
n : ℕ
a : α
hpos : 0 ≤ a
⊢ 0 ≤ n • a
Theorem: Complex.sin_two_mul
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [two_mul, sin_add, two_mul, add_mul, mul_comm]
state_before: x y : ℂ
⊢ sin (2 * x) = 2 * sin x * cos x
Theorem: one_lt_ack_succ_right
File: Mathlib/Computability/Ackermann.lean

tactic: simp
state_before: n : ℕ
⊢ 1 < ack 0 (n + 1)

tactic: rw [ack_succ_succ]
state_before: m n : ℕ
⊢ 1 < ack (m + 1) (n + 1)

tactic: cases' exists_eq_succ_of_ne_zero (ack_pos (m + 1) n).ne' with h h
state_before: m n : ℕ
⊢ 1 < ack m (ack (m + 1) n)

tactic: rw [h]
state_before: case intro
m n h✝ : ℕ
h : ack (m + 1) n = succ h✝
⊢ 1 < ack m (ack (m + 1) n)

tactic: apply one_lt_ack_succ_right
state_before: case intro
m n h✝ : ℕ
h : ack (m + 1) n = succ h✝
⊢ 1 < ack m (succ h✝)
Theorem: Rat.lt_one_iff_num_lt_denom
File: Mathlib/Data/Rat/Order.lean

tactic: simp [Rat.lt_def]
state_before: a b c q : ℚ
⊢ q < 1 ↔ q.num < ↑q.den
Theorem: Set.EqOn.inter_preimage_eq
File: Mathlib/Data/Set/Function.lean

tactic: rw [mem_preimage, mem_preimage, heq hx]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.7921
ι : Sort ?u.7924
π : α → Type ?u.7929
s s₁ s₂ : Set α
t✝ t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
heq : EqOn f₁ f₂ s
t : Set β
x : α
hx : x ∈ s
⊢ x ∈ f₁ ⁻¹' t ↔ x ∈ f₂ ⁻¹' t
Theorem: dist_vadd_right
File: Mathlib/Analysis/Normed/Group/AddTorsor.lean

tactic: rw [dist_comm, dist_vadd_left]
state_before: α : Type ?u.11888
V : Type u_2
P : Type u_1
W : Type ?u.11897
Q : Type ?u.11900
inst✝⁵ : SeminormedAddCommGroup V
inst✝⁴ : PseudoMetricSpace P
inst✝³ : NormedAddTorsor V P
inst✝² : NormedAddCommGroup W
inst✝¹ : MetricSpace Q
inst✝ : NormedAddTorsor W Q
v : V
x : P
⊢ dist x (v +ᵥ x) = ‖v‖
Theorem: dvd_mul
File: Mathlib/Algebra/GCDMonoid/Basic.lean

tactic: refine' ⟨exists_dvd_and_dvd_of_dvd_mul, _⟩
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
k m n : α
⊢ k ∣ m * n ↔ ∃ d₁ d₂, d₁ ∣ m ∧ d₂ ∣ n ∧ k = d₁ * d₂

tactic: rintro ⟨d₁, d₂, hy, hz, rfl⟩
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
k m n : α
⊢ (∃ d₁ d₂, d₁ ∣ m ∧ d₂ ∣ n ∧ k = d₁ * d₂) → k ∣ m * n

tactic: exact mul_dvd_mul hy hz
state_before: case intro.intro.intro.intro
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
m n d₁ d₂ : α
hy : d₁ ∣ m
hz : d₂ ∣ n
⊢ d₁ * d₂ ∣ m * n
Theorem: MeasureTheory.SimpleFunc.range_map
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: simp only [coe_range, coe_map, Finset.coe_image, range_comp]
state_before: α : Type u_2
β : Type u_3
γ : Type u_1
δ : Type ?u.57313
inst✝¹ : MeasurableSpace α
inst✝ : DecidableEq γ
g : β → γ
f : α →ₛ β
⊢ ↑(SimpleFunc.range (map g f)) = ↑(Finset.image g (SimpleFunc.range f))
Theorem: EuclideanGeometry.dist_div_tan_angle_of_angle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean

tactic: rw [angle, ← inner_eq_zero_iff_angle_eq_pi_div_two, real_inner_comm, ← neg_eq_zero, ←
  inner_neg_left, neg_vsub_eq_vsub_rev] at h
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : ∠ p₁ p₂ p₃ = π / 2
h0 : p₁ ≠ p₂ ∨ p₃ = p₂
⊢ dist p₁ p₂ / Real.tan (∠ p₂ p₃ p₁) = dist p₃ p₂

tactic: rw [eq_comm, ← @vsub_ne_zero V, ← @vsub_eq_zero_iff_eq V, or_comm] at h0
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : inner (p₂ -ᵥ p₃) (p₁ -ᵥ p₂) = 0
h0 : p₁ ≠ p₂ ∨ p₃ = p₂
⊢ dist p₁ p₂ / Real.tan (∠ p₂ p₃ p₁) = dist p₃ p₂

tactic: rw [angle, dist_eq_norm_vsub V p₁ p₂, dist_eq_norm_vsub' V p₃ p₂, ← vsub_add_vsub_cancel p₁ p₂ p₃,
  add_comm, norm_div_tan_angle_add_of_inner_eq_zero h h0]
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : inner (p₂ -ᵥ p₃) (p₁ -ᵥ p₂) = 0
h0 : p₂ -ᵥ p₃ = 0 ∨ p₁ -ᵥ p₂ ≠ 0
⊢ dist p₁ p₂ / Real.tan (∠ p₂ p₃ p₁) = dist p₃ p₂
Theorem: CategoryTheory.skeleton_skeletal
File: Mathlib/CategoryTheory/Skeletal.lean

tactic: rintro X Y ⟨h⟩
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
E : Type u₃
inst✝ : Category E
⊢ Skeletal (Skeleton C)

tactic: have : X.out ≈ Y.out := ⟨(fromSkeleton C).mapIso h⟩
state_before: case intro
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
E : Type u₃
inst✝ : Category E
X Y : Skeleton C
h : X ≅ Y
⊢ X = Y

tactic: simpa using Quotient.sound this
state_before: case intro
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
E : Type u₃
inst✝ : Category E
X Y : Skeleton C
h : X ≅ Y
this : Quotient.out X ≈ Quotient.out Y
⊢ X = Y