tasksource/leandojo huggingface dataset:
Theorem: BilinForm.mul_toMatrix'
File: Mathlib/LinearAlgebra/Matrix/BilinearForm.lean

tactic: simp only [toMatrix'_compLeft, transpose_transpose, toMatrix'_toLin']
state_before: R : Type ?u.834155
M✝ : Type ?u.834158
inst✝¹⁸ : Semiring R
inst✝¹⁷ : AddCommMonoid M✝
inst✝¹⁶ : Module R M✝
R₁ : Type ?u.834194
M₁ : Type ?u.834197
inst✝¹⁵ : Ring R₁
inst✝¹⁴ : AddCommGroup M₁
inst✝¹³ : Module R₁ M₁
R₂ : Type u_1
M₂ : Type ?u.834809
inst✝¹² : CommSemiring R₂
inst✝¹¹ : AddCommMonoid M₂
inst✝¹⁰ : Module R₂ M₂
R₃ : Type ?u.834996
M₃ : Type ?u.834999
inst✝⁹ : CommRing R₃
inst✝⁸ : AddCommGroup M₃
inst✝⁷ : Module R₃ M₃
V : Type ?u.835587
K : Type ?u.835590
inst✝⁶ : Field K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
B✝ : BilinForm R M✝
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
n : Type u_2
o : Type ?u.836807
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : DecidableEq n
inst✝ : DecidableEq o
B : BilinForm R₂ (n → R₂)
M : Matrix n n R₂
⊢ M ⬝ ↑toMatrix' B = ↑toMatrix' (compLeft B (↑Matrix.toLin' Mᵀ))
Theorem: lowerClosure_prod
File: Mathlib/Order/UpperLower/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.195438
ι : Sort ?u.195441
κ : ι → Sort ?u.195446
inst✝¹ : Preorder α
inst✝ : Preorder β
s : Set α
t : Set β
⊢ lowerClosure (s ×ˢ t) = lowerClosure s ×ˢ lowerClosure t

tactic: simp [Prod.le_def, @and_and_and_comm _ (_ ∈ t)]
state_before: case a.h
α : Type u_1
β : Type u_2
γ : Type ?u.195438
ι : Sort ?u.195441
κ : ι → Sort ?u.195446
inst✝¹ : Preorder α
inst✝ : Preorder β
s : Set α
t : Set β
x✝ : α × β
⊢ x✝ ∈ ↑(lowerClosure (s ×ˢ t)) ↔ x✝ ∈ ↑(lowerClosure s ×ˢ lowerClosure t)
Theorem: MeasureTheory.Measure.sub_eq_zero_of_le
File: Mathlib/MeasureTheory/Measure/Sub.lean

tactic: rwa [zero_add]
state_before: α : Type u_1
m : MeasurableSpace α
μ ν : Measure α
s : Set α
h : μ ≤ ν
⊢ μ ≤ 0 + ν
Theorem: CategoryTheory.isSubterminal_of_isIso_diag
File: Mathlib/CategoryTheory/Subterminal.lean

tactic: have : (Limits.prod.fst : A ⨯ A ⟶ _) = Limits.prod.snd := by simp [← cancel_epi (diag A)]
state_before: C : Type u₁
inst✝² : Category C
A : C
inst✝¹ : HasBinaryProduct A A
inst✝ : IsIso (diag A)
Z : C
f g : Z ⟶ A
⊢ f = g

tactic: rw [← prod.lift_fst f g, this, prod.lift_snd]
state_before: C : Type u₁
inst✝² : Category C
A : C
inst✝¹ : HasBinaryProduct A A
inst✝ : IsIso (diag A)
Z : C
f g : Z ⟶ A
this : prod.fst = prod.snd
⊢ f = g

tactic: simp [← cancel_epi (diag A)]
state_before: C : Type u₁
inst✝² : Category C
A : C
inst✝¹ : HasBinaryProduct A A
inst✝ : IsIso (diag A)
Z : C
f g : Z ⟶ A
⊢ prod.fst = prod.snd
Theorem: MeasureTheory.ae_lt_top
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: simp_rw [ae_iff, ENNReal.not_lt_top]
state_before: α : Type u_1
β : Type ?u.1736279
γ : Type ?u.1736282
δ : Type ?u.1736285
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : Measurable f
h2f : (∫⁻ (x : α), f x ∂μ) ≠ ⊤
⊢ ∀ᵐ (x : α) ∂μ, f x < ⊤

tactic: by_contra h
state_before: α : Type u_1
β : Type ?u.1736279
γ : Type ?u.1736282
δ : Type ?u.1736285
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : Measurable f
h2f : (∫⁻ (x : α), f x ∂μ) ≠ ⊤
⊢ ↑↑μ {a | f a = ⊤} = 0

tactic: apply h2f.lt_top.not_le
state_before: α : Type u_1
β : Type ?u.1736279
γ : Type ?u.1736282
δ : Type ?u.1736285
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : Measurable f
h2f : (∫⁻ (x : α), f x ∂μ) ≠ ⊤
h : ¬↑↑μ {a | f a = ⊤} = 0
⊢ False

tactic: have : (f ⁻¹' {∞}).indicator ⊤ ≤ f := by
  intro x
  by_cases hx : x ∈ f ⁻¹' {∞} <;> [simpa [indicator_of_mem hx]; simp [indicator_of_not_mem hx]]
state_before: α : Type u_1
β : Type ?u.1736279
γ : Type ?u.1736282
δ : Type ?u.1736285
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : Measurable f
h2f : (∫⁻ (x : α), f x ∂μ) ≠ ⊤
h : ¬↑↑μ {a | f a = ⊤} = 0
⊢ ⊤ ≤ ∫⁻ (x : α), f x ∂μ

tactic: convert lintegral_mono this
state_before: α : Type u_1
β : Type ?u.1736279
γ : Type ?u.1736282
δ : Type ?u.1736285
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : Measurable f
h2f : (∫⁻ (x : α), f x ∂μ) ≠ ⊤
h : ¬↑↑μ {a | f a = ⊤} = 0
this : indicator (f ⁻¹' {⊤}) ⊤ ≤ f
⊢ ⊤ ≤ ∫⁻ (x : α), f x ∂μ

tactic: rw [lintegral_indicator _ (hf (measurableSet_singleton ∞))]
state_before: case h.e'_3
α : Type u_1
β : Type ?u.1736279
γ : Type ?u.1736282
δ : Type ?u.1736285
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : Measurable f
h2f : (∫⁻ (x : α), f x ∂μ) ≠ ⊤
h : ¬↑↑μ {a | f a = ⊤} = 0
this : indicator (f ⁻¹' {⊤}) ⊤ ≤ f
⊢ ⊤ = ∫⁻ (a : α), indicator (f ⁻¹' {⊤}) ⊤ a ∂μ

tactic: simp [ENNReal.top_mul', preimage, h]
state_before: case h.e'_3
α : Type u_1
β : Type ?u.1736279
γ : Type ?u.1736282
δ : Type ?u.1736285
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : Measurable f
h2f : (∫⁻ (x : α), f x ∂μ) ≠ ⊤
h : ¬↑↑μ {a | f a = ⊤} = 0
this : indicator (f ⁻¹' {⊤}) ⊤ ≤ f
⊢ ⊤ = ∫⁻ (a : α) in f ⁻¹' {⊤}, ⊤ a ∂μ

tactic: intro x
state_before: α : Type u_1
β : Type ?u.1736279
γ : Type ?u.1736282
δ : Type ?u.1736285
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : Measurable f
h2f : (∫⁻ (x : α), f x ∂μ) ≠ ⊤
h : ¬↑↑μ {a | f a = ⊤} = 0
⊢ indicator (f ⁻¹' {⊤}) ⊤ ≤ f

tactic: by_cases hx : x ∈ f ⁻¹' {∞} <;> [simpa [indicator_of_mem hx]; simp [indicator_of_not_mem hx]]
state_before: α : Type u_1
β : Type ?u.1736279
γ : Type ?u.1736282
δ : Type ?u.1736285
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : Measurable f
h2f : (∫⁻ (x : α), f x ∂μ) ≠ ⊤
h : ¬↑↑μ {a | f a = ⊤} = 0
x : α
⊢ indicator (f ⁻¹' {⊤}) ⊤ x ≤ f x
Theorem: AlgebraicGeometry.StructureSheaf.const_mul
File: Mathlib/AlgebraicGeometry/StructureSheaf.lean

tactic: convert IsLocalization.mk'_mul _ f₁ f₂ ⟨g₁, hu₁ x x.2⟩ ⟨g₂, hu₂ x x.2⟩
state_before: R : Type u
inst✝ : CommRing R
f₁ f₂ g₁ g₂ : R
U : Opens ↑(PrimeSpectrum.Top R)
hu₁ : ∀ (x : ↑(PrimeSpectrum.Top R)), x ∈ U → g₁ ∈ Ideal.primeCompl x.asIdeal
hu₂ : ∀ (x : ↑(PrimeSpectrum.Top R)), x ∈ U → g₂ ∈ Ideal.primeCompl x.asIdeal
x : { x // x ∈ U.op.unop }
⊢ ↑(const R (f₁ * f₂) (g₁ * g₂) U (_ : ∀ (x : ↑(PrimeSpectrum.Top R)), x ∈ U → g₁ * g₂ ∈ Ideal.primeCompl x.asIdeal))
      x =
    ↑(const R f₁ g₁ U hu₁ * const R f₂ g₂ U hu₂) x
Theorem: PrincipalIdealRing.factors_spec
File: Mathlib/RingTheory/PrincipalIdealDomain.lean

tactic: unfold factors
state_before: R : Type u
M : Type v
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : IsPrincipalIdealRing R
a : R
h : a ≠ 0
⊢ (∀ (b : R), b ∈ factors a → Irreducible b) ∧ Associated (Multiset.prod (factors a)) a

tactic: rw [dif_neg h]
state_before: R : Type u
M : Type v
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : IsPrincipalIdealRing R
a : R
h : a ≠ 0
⊢ (∀ (b : R),
      (b ∈
          if h : a = 0 then ∅
          else choose (_ : ∃ f, (∀ (b : R), b ∈ f → Irreducible b) ∧ Associated (Multiset.prod f) a)) →
        Irreducible b) ∧
    Associated
      (Multiset.prod
        (if h : a = 0 then ∅
        else choose (_ : ∃ f, (∀ (b : R), b ∈ f → Irreducible b) ∧ Associated (Multiset.prod f) a)))
      a

tactic: exact Classical.choose_spec (WfDvdMonoid.exists_factors a h)
state_before: R : Type u
M : Type v
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : IsPrincipalIdealRing R
a : R
h : a ≠ 0
⊢ (∀ (b : R),
      b ∈ choose (_ : ∃ f, (∀ (b : R), b ∈ f → Irreducible b) ∧ Associated (Multiset.prod f) a) → Irreducible b) ∧
    Associated (Multiset.prod (choose (_ : ∃ f, (∀ (b : R), b ∈ f → Irreducible b) ∧ Associated (Multiset.prod f) a))) a
Theorem: Array.get_push_eq
File: Std/Data/Array/Init/Lemmas.lean

tactic: simp only [push, getElem_eq_data_get, List.concat_eq_append]
state_before: α : Type u_1
a : Array α
x : α
⊢ (push a x)[size a] = x

tactic: rw [List.get_append_right] <;> simp [getElem_eq_data_get]
state_before: α : Type u_1
a : Array α
x : α
⊢ List.get (a.data ++ [x])
      { val := size a, isLt := (_ : (fun xs i => i < size xs) { data := a.data ++ [x] } (size a)) } =
    x
Theorem: Multiset.bind_assoc
File: Mathlib/Data/Multiset/Bind.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.34299
a : α
s✝ t : Multiset α
f✝ g✝ : α → Multiset β
s : Multiset α
f : α → Multiset β
g : β → Multiset γ
⊢ bind (bind 0 f) g = bind 0 fun a => bind (f a) g

tactic: simp (config := { contextual := true })
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.34299
a : α
s✝ t : Multiset α
f✝ g✝ : α → Multiset β
s : Multiset α
f : α → Multiset β
g : β → Multiset γ
⊢ ∀ ⦃a : α⦄ {s : Multiset α},
    (bind (bind s f) g = bind s fun a => bind (f a) g) →
      bind (bind (a ::ₘ s) f) g = bind (a ::ₘ s) fun a => bind (f a) g
Theorem: differentiableAt_add_const_iff
File: Mathlib/Analysis/Calculus/FDeriv/Add.lean

tactic: simpa using h.add_const (-c)
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.207343
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.207438
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
c : F
h : DifferentiableAt 𝕜 (fun y => f y + c) x
⊢ DifferentiableAt 𝕜 f x
Theorem: Bornology.isBounded_ofBounded_iff
File: Mathlib/Topology/Bornology/Basic.lean

tactic: rw [@isBounded_def _ (ofBounded B empty_mem subset_mem union_mem sUnion_univ), ← Filter.mem_sets,
 ofBounded_cobounded_sets, Set.mem_setOf_eq, compl_compl]
state_before: ι : Type ?u.6781
α : Type u_1
β : Type ?u.6787
s : Set α
B : Set (Set α)
empty_mem : ∅ ∈ B
subset_mem : ∀ (s₁ : Set α), s₁ ∈ B → ∀ (s₂ : Set α), s₂ ⊆ s₁ → s₂ ∈ B
union_mem : ∀ (s₁ : Set α), s₁ ∈ B → ∀ (s₂ : Set α), s₂ ∈ B → s₁ ∪ s₂ ∈ B
sUnion_univ : ∀ (x : α), {x} ∈ B
⊢ IsBounded s ↔ s ∈ B
Theorem: Polynomial.Monic.irreducible_iff_natDegree
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: by_cases hp1 : p = 1
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommSemiring R
inst✝ : NoZeroDivisors R
p q : R[X]
hp : Monic p
⊢ Irreducible p ↔ p ≠ 1 ∧ ∀ (f g : R[X]), Monic f → Monic g → f * g = p → natDegree f = 0 ∨ natDegree g = 0

tactic: rw [irreducible_of_monic hp hp1, and_iff_right hp1]
state_before: case neg
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommSemiring R
inst✝ : NoZeroDivisors R
p q : R[X]
hp : Monic p
hp1 : ¬p = 1
⊢ Irreducible p ↔ p ≠ 1 ∧ ∀ (f g : R[X]), Monic f → Monic g → f * g = p → natDegree f = 0 ∨ natDegree g = 0

tactic: refine' forall₄_congr fun a b ha hb => _
state_before: case neg
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommSemiring R
inst✝ : NoZeroDivisors R
p q : R[X]
hp : Monic p
hp1 : ¬p = 1
⊢ (∀ (f g : R[X]), Monic f → Monic g → f * g = p → f = 1 ∨ g = 1) ↔
    ∀ (f g : R[X]), Monic f → Monic g → f * g = p → natDegree f = 0 ∨ natDegree g = 0

tactic: rw [ha.natDegree_eq_zero_iff_eq_one, hb.natDegree_eq_zero_iff_eq_one]
state_before: case neg
R : Type u
S : Type v
T : Type w
a✝ b✝ : R
n : ℕ
inst✝¹ : CommSemiring R
inst✝ : NoZeroDivisors R
p q : R[X]
hp : Monic p
hp1 : ¬p = 1
a b : R[X]
ha : Monic a
hb : Monic b
⊢ a * b = p → a = 1 ∨ b = 1 ↔ a * b = p → natDegree a = 0 ∨ natDegree b = 0

tactic: simp [hp1]
state_before: case pos
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommSemiring R
inst✝ : NoZeroDivisors R
p q : R[X]
hp : Monic p
hp1 : p = 1
⊢ Irreducible p ↔ p ≠ 1 ∧ ∀ (f g : R[X]), Monic f → Monic g → f * g = p → natDegree f = 0 ∨ natDegree g = 0
Theorem: Turing.Tape.mk'_left_right₀
File: Mathlib/Computability/TuringMachine.lean

tactic: cases T
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
T : Tape Γ
⊢ mk' T.left (right₀ T) = T

tactic: simp only [Tape.right₀, Tape.mk', ListBlank.head_cons, ListBlank.tail_cons, eq_self_iff_true,
  and_self_iff]
state_before: case mk
Γ : Type u_1
inst✝ : Inhabited Γ
head✝ : Γ
left✝ right✝ : ListBlank Γ
⊢ mk' { head := head✝, left := left✝, right := right✝ }.left
      (right₀ { head := head✝, left := left✝, right := right✝ }) =
    { head := head✝, left := left✝, right := right✝ }
Theorem: ZMod.natAbs_mod_two
File: Mathlib/Data/ZMod/Basic.lean

tactic: cases a
state_before: a : ℤ
⊢ ↑(Int.natAbs a) = ↑a

tactic: simp only [Int.natAbs_ofNat, Int.cast_ofNat, Int.ofNat_eq_coe]
state_before: case ofNat
a✝ : ℕ
⊢ ↑(Int.natAbs (Int.ofNat a✝)) = ↑(Int.ofNat a✝)

tactic: simp only [neg_eq_self_mod_two, Nat.cast_succ, Int.natAbs, Int.cast_negSucc]
state_before: case negSucc
a✝ : ℕ
⊢ ↑(Int.natAbs (Int.negSucc a✝)) = ↑(Int.negSucc a✝)
Theorem: List.nthLe_length_sub_one
File: Mathlib/Data/List/Basic.lean

tactic: rintro rfl
state_before: ι : Type ?u.89110
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
h : length l - 1 < length l
⊢ l ≠ []

tactic: exact Nat.lt_irrefl 0 h
state_before: ι : Type ?u.89110
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
h : length [] - 1 < length []
⊢ False
Theorem: Multiset.count_dedup
File: Mathlib/Data/Multiset/Dedup.lean

tactic: simp only [quot_mk_to_coe'', coe_dedup, mem_coe, List.mem_dedup, coe_nodup, coe_count]
state_before: α : Type u_1
β : Type ?u.3980
inst✝ : DecidableEq α
m : Multiset α
a : α
x✝ : List α
⊢ count a (dedup (Quot.mk Setoid.r x✝)) = if a ∈ Quot.mk Setoid.r x✝ then 1 else 0

tactic: apply List.count_dedup _ _
state_before: α : Type u_1
β : Type ?u.3980
inst✝ : DecidableEq α
m : Multiset α
a : α
x✝ : List α
⊢ List.count a (List.dedup x✝) = if a ∈ x✝ then 1 else 0
Theorem: MeasurableSet.subtype_image
File: Mathlib/MeasureTheory/MeasurableSpace.lean

tactic: rintro ⟨u, hu, rfl⟩
state_before: α : Type u_1
β : Type ?u.60270
γ : Type ?u.60273
δ : Type ?u.60276
δ' : Type ?u.60279
ι : Sort uι
s✝ t✝ u : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
s : Set α
t : Set ↑s
hs : MeasurableSet s
⊢ MeasurableSet t → MeasurableSet (Subtype.val '' t)

tactic: rw [Subtype.image_preimage_coe]
state_before: case intro.intro
α : Type u_1
β : Type ?u.60270
γ : Type ?u.60273
δ : Type ?u.60276
δ' : Type ?u.60279
ι : Sort uι
s✝ t u✝ : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
s : Set α
hs : MeasurableSet s
u : Set α
hu : MeasurableSet u
⊢ MeasurableSet (Subtype.val '' (Subtype.val ⁻¹' u))

tactic: exact hu.inter hs
state_before: case intro.intro
α : Type u_1
β : Type ?u.60270
γ : Type ?u.60273
δ : Type ?u.60276
δ' : Type ?u.60279
ι : Sort uι
s✝ t u✝ : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
s : Set α
hs : MeasurableSet s
u : Set α
hu : MeasurableSet u
⊢ MeasurableSet (u ∩ s)
Theorem: ack_one
File: Mathlib/Computability/Ackermann.lean

tactic: induction' n with n IH
state_before: n : ℕ
⊢ ack 1 n = n + 2

tactic: rfl
state_before: case zero

⊢ ack 1 zero = zero + 2

tactic: simp [IH]
state_before: case succ
n : ℕ
IH : ack 1 n = n + 2
⊢ ack 1 (succ n) = succ n + 2
Theorem: CauSeq.lim_eq_zero_iff
File: Mathlib/Data/Real/CauSeqCompletion.lean

tactic: have hf := equiv_lim f
state_before: α : Type u_1
inst✝³ : LinearOrderedField α
β : Type u_2
inst✝² : Ring β
abv : β → α
inst✝¹ : IsAbsoluteValue abv
inst✝ : IsComplete β abv
f : CauSeq β abv
h : lim f = 0
⊢ LimZero f

tactic: rw [h] at hf
state_before: α : Type u_1
inst✝³ : LinearOrderedField α
β : Type u_2
inst✝² : Ring β
abv : β → α
inst✝¹ : IsAbsoluteValue abv
inst✝ : IsComplete β abv
f : CauSeq β abv
h : lim f = 0
hf : f ≈ const abv (lim f)
⊢ LimZero f

tactic: exact (limZero_congr hf).mpr (const_limZero.mpr rfl)
state_before: α : Type u_1
inst✝³ : LinearOrderedField α
β : Type u_2
inst✝² : Ring β
abv : β → α
inst✝¹ : IsAbsoluteValue abv
inst✝ : IsComplete β abv
f : CauSeq β abv
h : lim f = 0
hf : f ≈ const abv 0
⊢ LimZero f

tactic: have h₁ : f = f - const abv 0 := ext fun n => by simp [sub_apply, const_apply]
state_before: α : Type u_1
inst✝³ : LinearOrderedField α
β : Type u_2
inst✝² : Ring β
abv : β → α
inst✝¹ : IsAbsoluteValue abv
inst✝ : IsComplete β abv
f : CauSeq β abv
h : LimZero f
⊢ lim f = 0

tactic: rw [h₁] at h
state_before: α : Type u_1
inst✝³ : LinearOrderedField α
β : Type u_2
inst✝² : Ring β
abv : β → α
inst✝¹ : IsAbsoluteValue abv
inst✝ : IsComplete β abv
f : CauSeq β abv
h : LimZero f
h₁ : f = f - const abv 0
⊢ lim f = 0

tactic: exact lim_eq_of_equiv_const h
state_before: α : Type u_1
inst✝³ : LinearOrderedField α
β : Type u_2
inst✝² : Ring β
abv : β → α
inst✝¹ : IsAbsoluteValue abv
inst✝ : IsComplete β abv
f : CauSeq β abv
h : LimZero (f - const abv 0)
h₁ : f = f - const abv 0
⊢ lim f = 0

tactic: simp [sub_apply, const_apply]
state_before: α : Type u_1
inst✝³ : LinearOrderedField α
β : Type u_2
inst✝² : Ring β
abv : β → α
inst✝¹ : IsAbsoluteValue abv
inst✝ : IsComplete β abv
f : CauSeq β abv
h : LimZero f
n : ℕ
⊢ ↑f n = ↑(f - const abv 0) n
Theorem: CircleDeg1Lift.isUnit_iff_bijective
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: simp only [Equiv.ofBijective_apply_symm_apply f h, hxy]
state_before: f✝ g f : CircleDeg1Lift
h : Bijective ↑f
x y : ℝ
hxy : x ≤ y
⊢ ↑f (↑(Equiv.ofBijective (↑f) h).symm x) ≤ ↑f (↑(Equiv.ofBijective (↑f) h).symm y)

tactic: simp only [Equiv.ofBijective_apply_symm_apply f, f.map_add_one]
state_before: f✝ g f : CircleDeg1Lift
h : Bijective ↑f
x : ℝ
⊢ ↑f
      (↑{ toFun := ↑(Equiv.ofBijective (↑f) h).symm,
            monotone' :=
              (_ : ∀ (x y : ℝ), x ≤ y → ↑(Equiv.ofBijective (↑f) h).symm x ≤ ↑(Equiv.ofBijective (↑f) h).symm y) }
        (x + 1)) =
    ↑f
      (↑{ toFun := ↑(Equiv.ofBijective (↑f) h).symm,
              monotone' :=
                (_ : ∀ (x y : ℝ), x ≤ y → ↑(Equiv.ofBijective (↑f) h).symm x ≤ ↑(Equiv.ofBijective (↑f) h).symm y) }
          x +
        1)
Theorem: Polynomial.eval₂_at_apply
File: Mathlib/Data/Polynomial/Eval.lean

tactic: rw [eval₂_eq_sum, eval_eq_sum, sum, sum, f.map_sum]
state_before: R : Type u
S✝ : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q r✝ : R[X]
x : R
S : Type u_1
inst✝ : Semiring S
f : R →+* S
r : R
⊢ eval₂ f (↑f r) p = ↑f (eval r p)

tactic: simp only [f.map_mul, f.map_pow]
state_before: R : Type u
S✝ : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q r✝ : R[X]
x : R
S : Type u_1
inst✝ : Semiring S
f : R →+* S
r : R
⊢ ∑ n in support p, ↑f (coeff p n) * ↑f r ^ n = ∑ x in support p, ↑f (coeff p x * r ^ x)
Theorem: Submodule.biInf_comap_proj
File: Mathlib/LinearAlgebra/Pi.lean

tactic: ext x
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
φ : ι → Type u_1
inst✝¹ : (i : ι) → AddCommMonoid (φ i)
inst✝ : (i : ι) → Module R (φ i)
I : Set ι
p q : (i : ι) → Submodule R (φ i)
x : (i : ι) → φ i
⊢ (⨅ (i : ι) (_ : i ∈ I), comap (proj i) (p i)) = pi I p

tactic: simp
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
φ : ι → Type u_1
inst✝¹ : (i : ι) → AddCommMonoid (φ i)
inst✝ : (i : ι) → Module R (φ i)
I : Set ι
p q : (i : ι) → Submodule R (φ i)
x✝ x : (i : ι) → φ i
⊢ (x ∈ ⨅ (i : ι) (_ : i ∈ I), comap (proj i) (p i)) ↔ x ∈ pi I p
Theorem: compare_eq_iff_eq
File: Mathlib/Init/Algebra/Order.lean

tactic: rw [LinearOrder.compare_eq_compareOfLessAndEq, compareOfLessAndEq]
state_before: α : Type u
inst✝ : LinearOrder α
a b : α
⊢ compare a b = Ordering.eq ↔ a = b

tactic: split_ifs <;> simp only []
state_before: α : Type u
inst✝ : LinearOrder α
a b : α
⊢ (if a < b then Ordering.lt else if a = b then Ordering.eq else Ordering.gt) = Ordering.eq ↔ a = b

tactic: case _ h   => exact false_iff_iff.2 <| ne_iff_lt_or_gt.2 <| .inl h
state_before: case inl
α : Type u
inst✝ : LinearOrder α
a b : α
h✝ : a < b
⊢ False ↔ a = b

case inr.inl
α : Type u
inst✝ : LinearOrder α
a b : α
h✝¹ : ¬a < b
h✝ : a = b
⊢ True ↔ a = b

case inr.inr
α : Type u
inst✝ : LinearOrder α
a b : α
h✝¹ : ¬a < b
h✝ : ¬a = b
⊢ False ↔ a = b

tactic: case _ _ h => exact true_iff_iff.2 h
state_before: case inr.inl
α : Type u
inst✝ : LinearOrder α
a b : α
h✝¹ : ¬a < b
h✝ : a = b
⊢ True ↔ a = b

case inr.inr
α : Type u
inst✝ : LinearOrder α
a b : α
h✝¹ : ¬a < b
h✝ : ¬a = b
⊢ False ↔ a = b

tactic: case _ _ h => exact false_iff_iff.2 h
state_before: case inr.inr
α : Type u
inst✝ : LinearOrder α
a b : α
h✝¹ : ¬a < b
h✝ : ¬a = b
⊢ False ↔ a = b

tactic: exact false_iff_iff.2 <| ne_iff_lt_or_gt.2 <| .inl h
state_before: α : Type u
inst✝ : LinearOrder α
a b : α
h : a < b
⊢ False ↔ a = b

tactic: exact true_iff_iff.2 h
state_before: α : Type u
inst✝ : LinearOrder α
a b : α
h✝ : ¬a < b
h : a = b
⊢ True ↔ a = b

tactic: exact false_iff_iff.2 h
state_before: α : Type u
inst✝ : LinearOrder α
a b : α
h✝ : ¬a < b
h : ¬a = b
⊢ False ↔ a = b
Theorem: eq_zero_of_sameRay_self_neg
File: Mathlib/LinearAlgebra/Ray.lean

tactic: nontriviality M
state_before: R : Type u_1
inst✝⁵ : StrictOrderedCommRing R
M : Type u_2
N : Type ?u.156166
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup N
inst✝² : Module R M
inst✝¹ : Module R N
x y : M
inst✝ : NoZeroSMulDivisors R M
h : SameRay R x (-x)
⊢ x = 0

tactic: haveI : Nontrivial R := Module.nontrivial R M
state_before: R : Type u_1
inst✝⁵ : StrictOrderedCommRing R
M : Type u_2
N : Type ?u.156166
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup N
inst✝² : Module R M
inst✝¹ : Module R N
x y : M
inst✝ : NoZeroSMulDivisors R M
h : SameRay R x (-x)
✝ : Nontrivial M
⊢ x = 0

tactic: refine' eq_zero_of_sameRay_neg_smul_right (neg_lt_zero.2 (zero_lt_one' R)) _
state_before: R : Type u_1
inst✝⁵ : StrictOrderedCommRing R
M : Type u_2
N : Type ?u.156166
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup N
inst✝² : Module R M
inst✝¹ : Module R N
x y : M
inst✝ : NoZeroSMulDivisors R M
h : SameRay R x (-x)
✝ : Nontrivial M
this : Nontrivial R
⊢ x = 0

tactic: rwa [neg_one_smul]
state_before: R : Type u_1
inst✝⁵ : StrictOrderedCommRing R
M : Type u_2
N : Type ?u.156166
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup N
inst✝² : Module R M
inst✝¹ : Module R N
x y : M
inst✝ : NoZeroSMulDivisors R M
h : SameRay R x (-x)
✝ : Nontrivial M
this : Nontrivial R
⊢ SameRay R x (-1 • x)
Theorem: MeasureTheory.Measure.measure_eq_left_of_subset_of_measure_add_eq
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: refine' le_antisymm (measure_mono h') _
state_before: α : Type u_1
β : Type ?u.136128
γ : Type ?u.136131
δ : Type ?u.136134
ι : Type ?u.136137
R : Type ?u.136140
R' : Type ?u.136143
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ s t : Set α
h : ↑↑(μ + ν) t ≠ ⊤
h' : s ⊆ t
h'' : ↑↑(μ + ν) s = ↑↑(μ + ν) t
⊢ ↑↑μ s = ↑↑μ t

tactic: have : μ t + ν t ≤ μ s + ν t :=
  calc
    μ t + ν t = μ s + ν s := h''.symm
    _ ≤ μ s + ν t := add_le_add le_rfl (measure_mono h')
state_before: α : Type u_1
β : Type ?u.136128
γ : Type ?u.136131
δ : Type ?u.136134
ι : Type ?u.136137
R : Type ?u.136140
R' : Type ?u.136143
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ s t : Set α
h : ↑↑(μ + ν) t ≠ ⊤
h' : s ⊆ t
h'' : ↑↑(μ + ν) s = ↑↑(μ + ν) t
⊢ ↑↑μ t ≤ ↑↑μ s

tactic: apply ENNReal.le_of_add_le_add_right _ this
state_before: α : Type u_1
β : Type ?u.136128
γ : Type ?u.136131
δ : Type ?u.136134
ι : Type ?u.136137
R : Type ?u.136140
R' : Type ?u.136143
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ s t : Set α
h : ↑↑(μ + ν) t ≠ ⊤
h' : s ⊆ t
h'' : ↑↑(μ + ν) s = ↑↑(μ + ν) t
this : ↑↑μ t + ↑↑ν t ≤ ↑↑μ s + ↑↑ν t
⊢ ↑↑μ t ≤ ↑↑μ s

tactic: simp only [not_or, ENNReal.add_eq_top, Pi.add_apply, Ne.def, coe_add] at h
state_before: α : Type u_1
β : Type ?u.136128
γ : Type ?u.136131
δ : Type ?u.136134
ι : Type ?u.136137
R : Type ?u.136140
R' : Type ?u.136143
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ s t : Set α
h : ↑↑(μ + ν) t ≠ ⊤
h' : s ⊆ t
h'' : ↑↑(μ + ν) s = ↑↑(μ + ν) t
this : ↑↑μ t + ↑↑ν t ≤ ↑↑μ s + ↑↑ν t
⊢ ↑↑ν t ≠ ⊤

tactic: exact h.2
state_before: α : Type u_1
β : Type ?u.136128
γ : Type ?u.136131
δ : Type ?u.136134
ι : Type ?u.136137
R : Type ?u.136140
R' : Type ?u.136143
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ s t : Set α
h' : s ⊆ t
h'' : ↑↑(μ + ν) s = ↑↑(μ + ν) t
this : ↑↑μ t + ↑↑ν t ≤ ↑↑μ s + ↑↑ν t
h : ¬↑↑μ t = ⊤ ∧ ¬↑↑ν t = ⊤
⊢ ↑↑ν t ≠ ⊤