tasksource/leandojo huggingface dataset:
Theorem: LocalEquiv.IsImage.inter_eq_of_inter_eq_of_eqOn
File: Mathlib/Logic/Equiv/LocalEquiv.lean

tactic: rw [← h.image_eq, ← h'.image_eq, ← hs, heq.image_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.30560
δ : Type ?u.30563
e : LocalEquiv α β
e'✝ : LocalEquiv β γ
s : Set α
t : Set β
x : α
y : β
e' : LocalEquiv α β
h : IsImage e s t
h' : IsImage e' s t
hs : e.source ∩ s = e'.source ∩ s
heq : EqOn (↑e) (↑e') (e.source ∩ s)
⊢ e.target ∩ t = e'.target ∩ t
Theorem: Algebra.adjoin_induction'
File: Mathlib/RingTheory/Adjoin/Basic.lean

tactic: refine' Exists.elim _ fun (hx : x ∈ adjoin R s) (hc : p ⟨x, hx⟩) => hc
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
s t : Set A
p : { x // x ∈ adjoin R s } → Prop
Hs : ∀ (x : A) (h : x ∈ s), p { val := x, property := (_ : x ∈ ↑(adjoin R s)) }
Halg : ∀ (r : R), p (↑(algebraMap R { x // x ∈ adjoin R s }) r)
Hadd : ∀ (x y : { x // x ∈ adjoin R s }), p x → p y → p (x + y)
Hmul : ∀ (x y : { x // x ∈ adjoin R s }), p x → p y → p (x * y)
x✝ : { x // x ∈ adjoin R s }
x : A
hx : x ∈ adjoin R s
⊢ p { val := x, property := hx }

tactic: exact adjoin_induction hx (fun x hx => ⟨subset_adjoin hx, Hs x hx⟩)
  (fun r => ⟨Subalgebra.algebraMap_mem _ r, Halg r⟩)
  (fun x y hx hy =>
    Exists.elim hx fun hx' hx =>
      Exists.elim hy fun hy' hy => ⟨Subalgebra.add_mem _ hx' hy', Hadd _ _ hx hy⟩)
  fun x y hx hy =>
    Exists.elim hx fun hx' hx =>
      Exists.elim hy fun hy' hy => ⟨Subalgebra.mul_mem _ hx' hy', Hmul _ _ hx hy⟩
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
s t : Set A
p : { x // x ∈ adjoin R s } → Prop
Hs : ∀ (x : A) (h : x ∈ s), p { val := x, property := (_ : x ∈ ↑(adjoin R s)) }
Halg : ∀ (r : R), p (↑(algebraMap R { x // x ∈ adjoin R s }) r)
Hadd : ∀ (x y : { x // x ∈ adjoin R s }), p x → p y → p (x + y)
Hmul : ∀ (x y : { x // x ∈ adjoin R s }), p x → p y → p (x * y)
x✝ : { x // x ∈ adjoin R s }
x : A
hx : x ∈ adjoin R s
⊢ ∃ x_1, p { val := x, property := x_1 }
Theorem: Filter.Eventually.curry_nhds
File: Mathlib/Topology/Constructions.lean

tactic: rw [nhds_prod_eq] at h
state_before: α : Type u
β : Type v
γ : Type ?u.40439
δ : Type ?u.40442
ε : Type ?u.40445
ζ : Type ?u.40448
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : TopologicalSpace ε
inst✝ : TopologicalSpace ζ
p : α × β → Prop
x : α
y : β
h : ∀ᶠ (x : α × β) in 𝓝 (x, y), p x
⊢ ∀ᶠ (x' : α) in 𝓝 x, ∀ᶠ (y' : β) in 𝓝 y, p (x', y')

tactic: exact h.curry
state_before: α : Type u
β : Type v
γ : Type ?u.40439
δ : Type ?u.40442
ε : Type ?u.40445
ζ : Type ?u.40448
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : TopologicalSpace ε
inst✝ : TopologicalSpace ζ
p : α × β → Prop
x : α
y : β
h : ∀ᶠ (x : α × β) in 𝓝 x ×ˢ 𝓝 y, p x
⊢ ∀ᶠ (x' : α) in 𝓝 x, ∀ᶠ (y' : β) in 𝓝 y, p (x', y')
Theorem: tendsto_prod_filter_iff
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: simp_rw [nhds_eq_comap_uniformity, tendsto_comap_iff]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
c : β
⊢ Tendsto (↿F) (p ×ˢ p') (𝓝 c) ↔ TendstoUniformlyOnFilter F (fun x => c) p p'

tactic: rfl
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
c : β
⊢ Tendsto (Prod.mk c ∘ ↿F) (p ×ˢ p') (𝓤 β) ↔ TendstoUniformlyOnFilter F (fun x => c) p p'
Theorem: Sum.denselyOrdered_iff
File: Mathlib/Data/Sum/Order.lean

tactic: obtain ⟨c | c, ha, hb⟩ := @exists_between (Sum α β) _ _ _ _ (inl_lt_inl_iff.2 h)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.17805
δ : Type ?u.17808
inst✝¹ : LT α
inst✝ : LT β
x✝ : DenselyOrdered (α ⊕ β)
a b : α
h : a < b
⊢ ∃ a_1, a < a_1 ∧ a_1 < b

tactic: exact ⟨c, inl_lt_inl_iff.1 ha, inl_lt_inl_iff.1 hb⟩
state_before: case intro.inl.intro
α : Type u_1
β : Type u_2
γ : Type ?u.17805
δ : Type ?u.17808
inst✝¹ : LT α
inst✝ : LT β
x✝ : DenselyOrdered (α ⊕ β)
a b : α
h : a < b
c : α
ha : inl a < inl c
hb : inl c < inl b
⊢ ∃ a_1, a < a_1 ∧ a_1 < b

tactic: exact (not_inl_lt_inr ha).elim
state_before: case intro.inr.intro
α : Type u_1
β : Type u_2
γ : Type ?u.17805
δ : Type ?u.17808
inst✝¹ : LT α
inst✝ : LT β
x✝ : DenselyOrdered (α ⊕ β)
a b : α
h : a < b
c : β
ha : inl a < inr c
hb : inr c < inl b
⊢ ∃ a_1, a < a_1 ∧ a_1 < b

tactic: obtain ⟨c | c, ha, hb⟩ := @exists_between (Sum α β) _ _ _ _ (inr_lt_inr_iff.2 h)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.17805
δ : Type ?u.17808
inst✝¹ : LT α
inst✝ : LT β
x✝ : DenselyOrdered (α ⊕ β)
a b : β
h : a < b
⊢ ∃ a_1, a < a_1 ∧ a_1 < b

tactic: exact (not_inl_lt_inr hb).elim
state_before: case intro.inl.intro
α : Type u_1
β : Type u_2
γ : Type ?u.17805
δ : Type ?u.17808
inst✝¹ : LT α
inst✝ : LT β
x✝ : DenselyOrdered (α ⊕ β)
a b : β
h : a < b
c : α
ha : inr a < inl c
hb : inl c < inr b
⊢ ∃ a_1, a < a_1 ∧ a_1 < b

tactic: exact ⟨c, inr_lt_inr_iff.1 ha, inr_lt_inr_iff.1 hb⟩
state_before: case intro.inr.intro
α : Type u_1
β : Type u_2
γ : Type ?u.17805
δ : Type ?u.17808
inst✝¹ : LT α
inst✝ : LT β
x✝ : DenselyOrdered (α ⊕ β)
a b : β
h : a < b
c : β
ha : inr a < inr c
hb : inr c < inr b
⊢ ∃ a_1, a < a_1 ∧ a_1 < b
Theorem: essSup_eq_sInf
File: Mathlib/MeasureTheory/Function/EssSup.lean

tactic: dsimp [essSup, limsup, limsSup]
state_before: α : Type u_1
β : Type u_2
m✝ : MeasurableSpace α
μ✝ ν : MeasureTheory.Measure α
inst✝ : ConditionallyCompleteLinearOrder β
x : β
f✝ : α → β
m : MeasurableSpace α
μ : MeasureTheory.Measure α
f : α → β
⊢ essSup f μ = sInf {a | ↑↑μ {x | a < f x} = 0}

tactic: simp only [eventually_map, ae_iff, not_le]
state_before: α : Type u_1
β : Type u_2
m✝ : MeasurableSpace α
μ✝ ν : MeasureTheory.Measure α
inst✝ : ConditionallyCompleteLinearOrder β
x : β
f✝ : α → β
m : MeasurableSpace α
μ : MeasureTheory.Measure α
f : α → β
⊢ sInf {a | ∀ᶠ (n : β) in map f (Measure.ae μ), n ≤ a} = sInf {a | ↑↑μ {x | a < f x} = 0}
Theorem: Basis.dualBasis_repr
File: Mathlib/LinearAlgebra/Dual.lean

tactic: rw [← total_dualBasis b, Basis.total_repr b.dualBasis l]
state_before: R : Type u
M : Type v
K : Type u₁
V : Type u₂
ι : Type w
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : DecidableEq ι
b : Basis ι R M
inst✝ : _root_.Finite ι
l : Dual R M
i : ι
⊢ ↑(↑(dualBasis b).repr l) i = ↑l (↑b i)
Theorem: Fin.one_eq_zero_iff
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [eq_comm, zero_eq_one_iff]
state_before: n m : ℕ
inst✝ : NeZero n
⊢ 1 = 0 ↔ n = 1
Theorem: Array.foldl_induction
File: Std/Data/Array/Init/Lemmas.lean

tactic: have := SatisfiesM_foldlM (m := Id) (as := as) (f := f) motive h0
state_before: α : Type u_1
β : Type u_2
as : Array α
motive : Nat → β → Prop
init : β
h0 : motive 0 init
f : β → α → β
hf : ∀ (i : Fin (size as)) (b : β), motive i.val b → motive (i.val + 1) (f b as[i])
⊢ motive (size as) (foldl f init as 0 (size as))

tactic: simp [SatisfiesM_Id_eq] at this
state_before: α : Type u_1
β : Type u_2
as : Array α
motive : Nat → β → Prop
init : β
h0 : motive 0 init
f : β → α → β
hf : ∀ (i : Fin (size as)) (b : β), motive i.val b → motive (i.val + 1) (f b as[i])
this :
  (∀ (i : Fin (size as)) (b : β), motive i.val b → SatisfiesM (motive (i.val + 1)) (f b as[i])) →
    SatisfiesM (motive (size as)) (foldlM f init as 0 (size as))
⊢ motive (size as) (foldl f init as 0 (size as))

tactic: exact this hf
state_before: α : Type u_1
β : Type u_2
as : Array α
motive : Nat → β → Prop
init : β
h0 : motive 0 init
f : β → α → β
hf : ∀ (i : Fin (size as)) (b : β), motive i.val b → motive (i.val + 1) (f b as[i])
this :
  (∀ (i : Fin (size as)) (b : β), motive i.val b → motive (i.val + 1) (f b as[i])) →
    motive (size as) (foldlM f init as 0 (size as))
⊢ motive (size as) (foldl f init as 0 (size as))
Theorem: Substring.ValidFor.prevn
File: Std/Data/String/Lemmas.lean

tactic: simp [Substring.prevn]
state_before: l m₂ r m₁ : List Char
x✝¹ : Substring
x✝ : ValidFor l (List.reverse m₁ ++ m₂) r x✝¹
⊢ Substring.prevn x✝¹ 0 { byteIdx := utf8Len m₁ } = { byteIdx := utf8Len (List.drop 0 m₁) }

tactic: simp [Substring.prevn]
state_before: l m₂ r m₁ : List Char
s : Substring
h : ValidFor l (List.reverse m₁ ++ m₂) r s
n : Nat
⊢ Substring.prevn s (n + 1) { byteIdx := utf8Len m₁ } = { byteIdx := utf8Len (List.drop (n + 1) m₁) }

tactic: match m₁ with
| [] => simp
| c::m₁ =>
  rw [List.reverse_cons, List.append_assoc] at h
  have := h.prev; simp at this; simp [this, h.prevn n]
state_before: l m₂ r m₁ : List Char
s : Substring
h : ValidFor l (List.reverse m₁ ++ m₂) r s
n : Nat
⊢ Substring.prevn s n (Substring.prev s { byteIdx := utf8Len m₁ }) = { byteIdx := utf8Len (List.drop (n + 1) m₁) }

tactic: simp
state_before: l m₂ r m₁ : List Char
s : Substring
n : Nat
h : ValidFor l (List.reverse [] ++ m₂) r s
⊢ Substring.prevn s n (Substring.prev s { byteIdx := utf8Len [] }) = { byteIdx := utf8Len (List.drop (n + 1) []) }

tactic: rw [List.reverse_cons, List.append_assoc] at h
state_before: l m₂ r m₁✝ : List Char
s : Substring
n : Nat
c : Char
m₁ : List Char
h : ValidFor l (List.reverse (c :: m₁) ++ m₂) r s
⊢ Substring.prevn s n (Substring.prev s { byteIdx := utf8Len (c :: m₁) }) =
    { byteIdx := utf8Len (List.drop (n + 1) (c :: m₁)) }

tactic: have := h.prev
state_before: l m₂ r m₁✝ : List Char
s : Substring
n : Nat
c : Char
m₁ : List Char
h : ValidFor l (List.reverse m₁ ++ ([c] ++ m₂)) r s
⊢ Substring.prevn s n (Substring.prev s { byteIdx := utf8Len (c :: m₁) }) =
    { byteIdx := utf8Len (List.drop (n + 1) (c :: m₁)) }

tactic: simp at this
state_before: l m₂ r m₁✝ : List Char
s : Substring
n : Nat
c : Char
m₁ : List Char
h : ValidFor l (List.reverse m₁ ++ ([c] ++ m₂)) r s
this : Substring.prev s { byteIdx := utf8Len (List.reverse m₁) + csize c } = { byteIdx := utf8Len (List.reverse m₁) }
⊢ Substring.prevn s n (Substring.prev s { byteIdx := utf8Len (c :: m₁) }) =
    { byteIdx := utf8Len (List.drop (n + 1) (c :: m₁)) }

tactic: simp [this, h.prevn n]
state_before: l m₂ r m₁✝ : List Char
s : Substring
n : Nat
c : Char
m₁ : List Char
h : ValidFor l (List.reverse m₁ ++ ([c] ++ m₂)) r s
this : Substring.prev s { byteIdx := utf8Len m₁ + csize c } = { byteIdx := utf8Len m₁ }
⊢ Substring.prevn s n (Substring.prev s { byteIdx := utf8Len (c :: m₁) }) =
    { byteIdx := utf8Len (List.drop (n + 1) (c :: m₁)) }
Theorem: ClassGroup.equiv_mk0
File: Mathlib/RingTheory/ClassGroup.lean

tactic: rw [ClassGroup.mk0, MonoidHom.comp_apply, ClassGroup.equiv_mk]
state_before: R : Type u_1
K : Type u_2
L : Type ?u.1295805
inst✝¹¹ : CommRing R
inst✝¹⁰ : Field K
inst✝⁹ : Field L
inst✝⁸ : DecidableEq L
inst✝⁷ : Algebra R K
inst✝⁶ : IsFractionRing R K
inst✝⁵ : Algebra K L
inst✝⁴ : FiniteDimensional K L
inst✝³ : Algebra R L
inst✝² : IsScalarTower R K L
inst✝¹ : IsDomain R
inst✝ : IsDedekindDomain R
I : { x // x ∈ (Ideal R)⁰ }
⊢ ↑(equiv K) (↑mk0 I) = ↑(QuotientGroup.mk' (MonoidHom.range (toPrincipalIdeal R K))) (↑(FractionalIdeal.mk0 K) I)

tactic: congr 1
state_before: R : Type u_1
K : Type u_2
L : Type ?u.1295805
inst✝¹¹ : CommRing R
inst✝¹⁰ : Field K
inst✝⁹ : Field L
inst✝⁸ : DecidableEq L
inst✝⁷ : Algebra R K
inst✝⁶ : IsFractionRing R K
inst✝⁵ : Algebra K L
inst✝⁴ : FiniteDimensional K L
inst✝³ : Algebra R L
inst✝² : IsScalarTower R K L
inst✝¹ : IsDomain R
inst✝ : IsDedekindDomain R
I : { x // x ∈ (Ideal R)⁰ }
⊢ ↑(QuotientGroup.mk' (MonoidHom.range (toPrincipalIdeal R K)))
      (↑(Units.mapEquiv ↑(canonicalEquiv R⁰ (FractionRing R) K)) (↑(FractionalIdeal.mk0 (FractionRing R)) I)) =
    ↑(QuotientGroup.mk' (MonoidHom.range (toPrincipalIdeal R K))) (↑(FractionalIdeal.mk0 K) I)

tactic: simp [← Units.eq_iff]
state_before: case h.e_6.h
R : Type u_1
K : Type u_2
L : Type ?u.1295805
inst✝¹¹ : CommRing R
inst✝¹⁰ : Field K
inst✝⁹ : Field L
inst✝⁸ : DecidableEq L
inst✝⁷ : Algebra R K
inst✝⁶ : IsFractionRing R K
inst✝⁵ : Algebra K L
inst✝⁴ : FiniteDimensional K L
inst✝³ : Algebra R L
inst✝² : IsScalarTower R K L
inst✝¹ : IsDomain R
inst✝ : IsDedekindDomain R
I : { x // x ∈ (Ideal R)⁰ }
⊢ ↑(Units.mapEquiv ↑(canonicalEquiv R⁰ (FractionRing R) K)) (↑(FractionalIdeal.mk0 (FractionRing R)) I) =
    ↑(FractionalIdeal.mk0 K) I
Theorem: Dfinsupp.lsum_single
File: Mathlib/LinearAlgebra/Dfinsupp.lean

tactic: simp
state_before: ι : Type u_5
R : Type u_3
S : Type u_1
M : ι → Type u_4
N : Type u_2
dec_ι : DecidableEq ι
inst✝⁷ : Semiring R
inst✝⁶ : (i : ι) → AddCommMonoid (M i)
inst✝⁵ : (i : ι) → Module R (M i)
inst✝⁴ : AddCommMonoid N
inst✝³ : Module R N
inst✝² : Semiring S
inst✝¹ : Module S N
inst✝ : SMulCommClass R S N
F : (i : ι) → M i →ₗ[R] N
i : ι
x : M i
⊢ ↑(↑(lsum S) F) (single i x) = ↑(F i) x
Theorem: Nat.pow_lt_ascFactorial
File: Mathlib/Data/Nat/Factorial/Basic.lean

tactic: rintro ⟨⟩
state_before: n : ℕ
⊢ 2 ≤ 0 → (n + 1) ^ 0 < ascFactorial n 0

tactic: intro
state_before: n : ℕ
⊢ 2 ≤ 1 → (n + 1) ^ 1 < ascFactorial n 1

tactic: contradiction
state_before: n : ℕ
a✝ : 2 ≤ 1
⊢ (n + 1) ^ 1 < ascFactorial n 1
Theorem: List.splitOnP.go_ne_nil
File: Mathlib/Data/List/Basic.lean

tactic: induction xs generalizing acc <;> simp [go]
state_before: ι : Type ?u.292233
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
p : α → Bool
xs✝ ys : List α
ls : List (List α)
f : List α → List α
xs acc : List α
⊢ go p xs acc ≠ []

tactic: split <;> simp [*]
state_before: case cons
ι : Type ?u.292233
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
p : α → Bool
xs ys : List α
ls : List (List α)
f : List α → List α
head✝ : α
tail✝ : List α
tail_ih✝ : ∀ (acc : List α), go p tail✝ acc ≠ []
acc : List α
⊢ ¬(if p head✝ = true then reverse acc :: go p tail✝ [] else go p tail✝ (head✝ :: acc)) = []
Theorem: Multiset.le_prod_of_submultiplicative
File: Mathlib/Algebra/BigOperators/Multiset/Basic.lean

tactic: simp
state_before: ι : Type ?u.144665
α : Type u_1
β : Type u_2
γ : Type ?u.144674
inst✝¹ : CommMonoid α
inst✝ : OrderedCommMonoid β
f : α → β
h_one : f 1 = 1
h_mul : ∀ (a b : α), f (a * b) ≤ f a * f b
s : Multiset α
⊢ ∀ (a b : α), (fun x => True) a → (fun x => True) b → (fun x => True) (a * b)

tactic: simp
state_before: ι : Type ?u.144665
α : Type u_1
β : Type u_2
γ : Type ?u.144674
inst✝¹ : CommMonoid α
inst✝ : OrderedCommMonoid β
f : α → β
h_one : f 1 = 1
h_mul : ∀ (a b : α), f (a * b) ≤ f a * f b
s : Multiset α
⊢ ∀ (a : α), a ∈ s → (fun x => True) a
Theorem: OreLocalization.add_oreDiv
File: Mathlib/RingTheory/OreLocalization/Basic.lean

tactic: simp [oreDiv_add_char s s 1 1 (by simp)]
state_before: R : Type u_1
inst✝¹ : Semiring R
S : Submonoid R
inst✝ : OreSet S
r r' : R
s : { x // x ∈ S }
⊢ r /ₒ s + r' /ₒ s = (r + r') /ₒ s

tactic: simp
state_before: R : Type u_1
inst✝¹ : Semiring R
S : Submonoid R
inst✝ : OreSet S
r r' : R
s : { x // x ∈ S }
⊢ ↑s * ↑1 = ↑s * 1
Theorem: lt_norm_sub_of_not_sameRay
File: Mathlib/Analysis/Convex/StrictConvexSpace.lean

tactic: nth_rw 1 [← sub_add_cancel x y] at h⊢
state_before: 𝕜 : Type ?u.62097
E : Type u_1
inst✝⁴ : NormedLinearOrderedField 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace ℝ E
inst✝ : StrictConvexSpace ℝ E
x y z : E
a b r : ℝ
h : ¬SameRay ℝ x y
⊢ ‖x‖ - ‖y‖ < ‖x - y‖

tactic: exact sub_lt_iff_lt_add.2 (norm_add_lt_of_not_sameRay fun H' => h <| H'.add_left SameRay.rfl)
state_before: 𝕜 : Type ?u.62097
E : Type u_1
inst✝⁴ : NormedLinearOrderedField 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace ℝ E
inst✝ : StrictConvexSpace ℝ E
x y z : E
a b r : ℝ
h : ¬SameRay ℝ (x - y + y) y
⊢ ‖x - y + y‖ - ‖y‖ < ‖x - y‖
Theorem: Cardinal.mk_finsupp_of_infinite'
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: simp
state_before: α β : Type u
inst✝² : Nonempty α
inst✝¹ : Zero β
inst✝ : Infinite β
⊢ (#α →₀ β) = max (#α) (#β)
Theorem: PNat.XgcdType.start_isSpecial
File: Mathlib/Data/PNat/Xgcd.lean

tactic: dsimp [start, IsSpecial]
state_before: u : XgcdType
a b : ℕ+
⊢ IsSpecial (start a b)
Theorem: OrderIso.isAtomic_iff
File: Mathlib/Order/Atoms.lean

tactic: simp only [IsAtomic_iff, f.surjective.forall, f.surjective.exists, ← map_bot f, f.eq_iff_eq,
  f.le_iff_le, f.isAtom_iff]
state_before: α : Type u_1
β : Type u_2
inst✝³ : PartialOrder α
inst✝² : PartialOrder β
inst✝¹ : OrderBot α
inst✝ : OrderBot β
f : α ≃o β
⊢ IsAtomic α ↔ IsAtomic β
Theorem: Ideal.quotientInfToPiQuotient_bijective
File: Mathlib/RingTheory/Ideal/Quotient.lean

tactic: rw [hrs]
state_before: R : Type u
inst✝¹ : CommRing R
I : Ideal R
a b : R
S ι : Type v
inst✝ : Finite ι
f : ι → Ideal R
hf : ∀ (i j : ι), i ≠ j → f i ⊔ f j = ⊤
x y : R ⧸ ⨅ (i : ι), f i
r s : R
hrs : ↑(quotientInfToPiQuotient f) (Quotient.mk'' r) = ↑(quotientInfToPiQuotient f) (Quotient.mk'' s)
i : ι
⊢ ↑(quotientInfToPiQuotient f) (Quotient.mk'' r) i = ↑(Quotient.mk (f i)) s

tactic: rfl
state_before: R : Type u
inst✝¹ : CommRing R
I : Ideal R
a b : R
S ι : Type v
inst✝ : Finite ι
f : ι → Ideal R
hf : ∀ (i j : ι), i ≠ j → f i ⊔ f j = ⊤
x y : R ⧸ ⨅ (i : ι), f i
r s : R
hrs : ↑(quotientInfToPiQuotient f) (Quotient.mk'' r) = ↑(quotientInfToPiQuotient f) (Quotient.mk'' s)
i : ι
⊢ ↑(quotientInfToPiQuotient f) (Quotient.mk'' s) i = ↑(Quotient.mk (f i)) s
Theorem: BoxIntegral.Box.splitUpper_le
File: Mathlib/Analysis/BoxIntegral/Partition/Split.lean

tactic: simp
state_before: ι : Type u_1
M : Type ?u.12887
n : ℕ
I : Box ι
i : ι
x : ℝ
y : ι → ℝ
⊢ ↑(splitUpper I i x) ⊆ ↑↑I
Theorem: GeneralizedContinuedFraction.get?_of_eq_some_of_succ_get?_intFractPair_stream
File: Mathlib/Algebra/ContinuedFractions/Computation/Translations.lean

tactic: unfold of IntFractPair.seq1
state_before: K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n : ℕ
ifp_succ_n : IntFractPair K
stream_succ_nth_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
⊢ Stream'.Seq.get? (of v).s n = some { a := 1, b := ↑ifp_succ_n.b }

tactic: simp [Stream'.Seq.map_tail, Stream'.Seq.get?_tail, Stream'.Seq.map_get?, stream_succ_nth_eq]
state_before: K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n : ℕ
ifp_succ_n : IntFractPair K
stream_succ_nth_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
⊢ Stream'.Seq.get?
      (match
          (IntFractPair.of v,
            Stream'.Seq.tail
              { val := IntFractPair.stream v, property := (_ : Stream'.IsSeq (IntFractPair.stream v)) }) with
        | (h, s) => { h := ↑h.b, s := Stream'.Seq.map (fun p => { a := 1, b := ↑p.b }) s }).s
      n =
    some { a := 1, b := ↑ifp_succ_n.b }
Theorem: LieSubmodule.normalizer_inf
File: Mathlib/Algebra/Lie/Normalizer.lean

tactic: ext
state_before: R : Type u_2
L : Type u_3
M : Type u_1
M' : Type ?u.11866
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
⊢ normalizer (N₁ ⊓ N₂) = normalizer N₁ ⊓ normalizer N₂

tactic: simp [← forall_and]
state_before: case h
R : Type u_2
L : Type u_3
M : Type u_1
M' : Type ?u.11866
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
m✝ : M
⊢ m✝ ∈ normalizer (N₁ ⊓ N₂) ↔ m✝ ∈ normalizer N₁ ⊓ normalizer N₂
Theorem: List.mem_traverse
File: Mathlib/Control/Traversable/Instances.lean

tactic: simp
state_before: F G : Type u → Type u
inst✝² : Applicative F
inst✝¹ : Applicative G
α' β' : Type u
f✝ : α' → F β'
inst✝ : LawfulApplicative F
f : α' → Set β'
⊢ [] ∈ traverse f [] ↔ Forall₂ (fun b a => b ∈ f a) [] []

tactic: simp
state_before: F G : Type u → Type u
inst✝² : Applicative F
inst✝¹ : Applicative G
α' β' : Type u
f✝ : α' → F β'
inst✝ : LawfulApplicative F
f : α' → Set β'
a : α'
as : List α'
⊢ [] ∈ traverse f (a :: as) ↔ Forall₂ (fun b a => b ∈ f a) [] (a :: as)

tactic: simp
state_before: F G : Type u → Type u
inst✝² : Applicative F
inst✝¹ : Applicative G
α' β' : Type u
f✝ : α' → F β'
inst✝ : LawfulApplicative F
f : α' → Set β'
b : β'
bs : List β'
⊢ b :: bs ∈ traverse f [] ↔ Forall₂ (fun b a => b ∈ f a) (b :: bs) []

tactic: simp [mem_traverse as bs]
state_before: F G : Type u → Type u
inst✝² : Applicative F
inst✝¹ : Applicative G
α' β' : Type u
f✝ : α' → F β'
inst✝ : LawfulApplicative F
f : α' → Set β'
a : α'
as : List α'
b : β'
bs : List β'
⊢ b :: bs ∈ traverse f (a :: as) ↔ Forall₂ (fun b a => b ∈ f a) (b :: bs) (a :: as)
Theorem: Computation.empty_orelse
File: Mathlib/Data/Seq/Computation.lean

tactic: apply eq_of_bisim (fun c₁ c₂ => (empty α <|> c₂) = c₁) _ rfl
state_before: α : Type u
β : Type v
γ : Type w
c : Computation α
⊢ (HOrElse.hOrElse (empty α) fun x => c) = c

tactic: intro s' s h
state_before: α : Type u
β : Type v
γ : Type w
c : Computation α
⊢ IsBisimulation fun c₁ c₂ => (HOrElse.hOrElse (empty α) fun x => c₂) = c₁

tactic: rw [← h]
state_before: α : Type u
β : Type v
γ : Type w
c s' s : Computation α
h : (HOrElse.hOrElse (empty α) fun x => s) = s'
⊢ BisimO (fun c₁ c₂ => (HOrElse.hOrElse (empty α) fun x => c₂) = c₁) (destruct s') (destruct s)

tactic: apply recOn s <;> intro s <;> rw [think_empty] <;> simp
state_before: α : Type u
β : Type v
γ : Type w
c s' s : Computation α
h : (HOrElse.hOrElse (empty α) fun x => s) = s'
⊢ BisimO (fun c₁ c₂ => (HOrElse.hOrElse (empty α) fun x => c₂) = c₁) (destruct (HOrElse.hOrElse (empty α) fun x => s))
    (destruct s)

tactic: rw [← think_empty]
state_before: case h2
α : Type u
β : Type v
γ : Type w
c s' s✝ : Computation α
h : (HOrElse.hOrElse (empty α) fun x => s✝) = s'
s : Computation α
⊢ (HOrElse.hOrElse (think (empty α)) fun x => s) = HOrElse.hOrElse (empty α) fun x => s
Theorem: Sum.isRight_eq_false
File: Mathlib/Data/Sum/Basic.lean

tactic: cases x <;> simp
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type ?u.7480
δ : Type ?u.7483
x y : α ⊕ β
⊢ isRight x = false ↔ isLeft x = true
Theorem: IsScalarTower.algebraMap_smul
File: Mathlib/Algebra/Algebra/Tower.lean

tactic: rw [Algebra.algebraMap_eq_smul_one, smul_assoc, one_smul]
state_before: R : Type u
S : Type v
A : Type w
B : Type u₁
M : Type v₁
inst✝⁵ : CommSemiring R
inst✝⁴ : Semiring A
inst✝³ : Algebra R A
inst✝² : SMul R M
inst✝¹ : MulAction A M
inst✝ : IsScalarTower R A M
r : R
x : M
⊢ ↑(algebraMap R A) r • x = r • x