tasksource/leandojo huggingface dataset:
Theorem: MeasurableSpace.DynkinSystem.ext
File: Mathlib/MeasureTheory/PiSystem.lean

tactic: have : s₁ = s₂ := funext fun x => propext <| h x
state_before: α : Type u_1
s₁ : Set α → Prop
has_empty✝¹ : s₁ ∅
has_compl✝¹ : ∀ {a : Set α}, s₁ a → s₁ (aᶜ)
has_iUnion_nat✝¹ : ∀ {f : ℕ → Set α}, Pairwise (Disjoint on f) → (∀ (i : ℕ), s₁ (f i)) → s₁ (⋃ (i : ℕ), f i)
s₂ : Set α → Prop
has_empty✝ : s₂ ∅
has_compl✝ : ∀ {a : Set α}, s₂ a → s₂ (aᶜ)
has_iUnion_nat✝ : ∀ {f : ℕ → Set α}, Pairwise (Disjoint on f) → (∀ (i : ℕ), s₂ (f i)) → s₂ (⋃ (i : ℕ), f i)
h :
  ∀ (s : Set α),
    Has { Has := s₁, has_empty := has_empty✝¹, has_compl := has_compl✝¹, has_iUnion_nat := has_iUnion_nat✝¹ } s ↔
      Has { Has := s₂, has_empty := has_empty✝, has_compl := has_compl✝, has_iUnion_nat := has_iUnion_nat✝ } s
⊢ { Has := s₁, has_empty := has_empty✝¹, has_compl := has_compl✝¹, has_iUnion_nat := has_iUnion_nat✝¹ } =
    { Has := s₂, has_empty := has_empty✝, has_compl := has_compl✝, has_iUnion_nat := has_iUnion_nat✝ }

tactic: subst this
state_before: α : Type u_1
s₁ : Set α → Prop
has_empty✝¹ : s₁ ∅
has_compl✝¹ : ∀ {a : Set α}, s₁ a → s₁ (aᶜ)
has_iUnion_nat✝¹ : ∀ {f : ℕ → Set α}, Pairwise (Disjoint on f) → (∀ (i : ℕ), s₁ (f i)) → s₁ (⋃ (i : ℕ), f i)
s₂ : Set α → Prop
has_empty✝ : s₂ ∅
has_compl✝ : ∀ {a : Set α}, s₂ a → s₂ (aᶜ)
has_iUnion_nat✝ : ∀ {f : ℕ → Set α}, Pairwise (Disjoint on f) → (∀ (i : ℕ), s₂ (f i)) → s₂ (⋃ (i : ℕ), f i)
h :
  ∀ (s : Set α),
    Has { Has := s₁, has_empty := has_empty✝¹, has_compl := has_compl✝¹, has_iUnion_nat := has_iUnion_nat✝¹ } s ↔
      Has { Has := s₂, has_empty := has_empty✝, has_compl := has_compl✝, has_iUnion_nat := has_iUnion_nat✝ } s
this : s₁ = s₂
⊢ { Has := s₁, has_empty := has_empty✝¹, has_compl := has_compl✝¹, has_iUnion_nat := has_iUnion_nat✝¹ } =
    { Has := s₂, has_empty := has_empty✝, has_compl := has_compl✝, has_iUnion_nat := has_iUnion_nat✝ }

tactic: rfl
state_before: α : Type u_1
s₁ : Set α → Prop
has_empty✝¹ : s₁ ∅
has_compl✝¹ : ∀ {a : Set α}, s₁ a → s₁ (aᶜ)
has_iUnion_nat✝¹ : ∀ {f : ℕ → Set α}, Pairwise (Disjoint on f) → (∀ (i : ℕ), s₁ (f i)) → s₁ (⋃ (i : ℕ), f i)
has_empty✝ : s₁ ∅
has_compl✝ : ∀ {a : Set α}, s₁ a → s₁ (aᶜ)
has_iUnion_nat✝ : ∀ {f : ℕ → Set α}, Pairwise (Disjoint on f) → (∀ (i : ℕ), s₁ (f i)) → s₁ (⋃ (i : ℕ), f i)
h :
  ∀ (s : Set α),
    Has { Has := s₁, has_empty := has_empty✝¹, has_compl := has_compl✝¹, has_iUnion_nat := has_iUnion_nat✝¹ } s ↔
      Has { Has := s₁, has_empty := has_empty✝, has_compl := has_compl✝, has_iUnion_nat := has_iUnion_nat✝ } s
⊢ { Has := s₁, has_empty := has_empty✝¹, has_compl := has_compl✝¹, has_iUnion_nat := has_iUnion_nat✝¹ } =
    { Has := s₁, has_empty := has_empty✝, has_compl := has_compl✝, has_iUnion_nat := has_iUnion_nat✝ }
Theorem: DirectSum.coe_of_mul_apply
File: Mathlib/Algebra/DirectSum/Internal.lean

tactic: split_ifs with h
state_before: ι : Type u_3
σ : Type u_2
S : Type ?u.448211
R : Type u_1
inst✝⁹ : DecidableEq ι
inst✝⁸ : Semiring R
inst✝⁷ : SetLike σ R
inst✝⁶ : AddSubmonoidClass σ R
A : ι → σ
inst✝⁵ : CanonicallyOrderedAddMonoid ι
inst✝⁴ : SetLike.GradedMonoid A
inst✝³ : Sub ι
inst✝² : OrderedSub ι
inst✝¹ : ContravariantClass ι ι (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
i : ι
r : { x // x ∈ A i }
r' : ⨁ (i : ι), { x // x ∈ A i }
n : ι
inst✝ : Decidable (i ≤ n)
⊢ ↑(↑(↑(of (fun i => { x // x ∈ A i }) i) r * r') n) = if i ≤ n then ↑r * ↑(↑r' (n - i)) else 0

tactic: exacts [coe_of_mul_apply_of_le _ _ _ n h, coe_of_mul_apply_of_not_le _ _ _ n h]
state_before: case inl
ι : Type u_3
σ : Type u_2
S : Type ?u.448211
R : Type u_1
inst✝⁹ : DecidableEq ι
inst✝⁸ : Semiring R
inst✝⁷ : SetLike σ R
inst✝⁶ : AddSubmonoidClass σ R
A : ι → σ
inst✝⁵ : CanonicallyOrderedAddMonoid ι
inst✝⁴ : SetLike.GradedMonoid A
inst✝³ : Sub ι
inst✝² : OrderedSub ι
inst✝¹ : ContravariantClass ι ι (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
i : ι
r : { x // x ∈ A i }
r' : ⨁ (i : ι), { x // x ∈ A i }
n : ι
inst✝ : Decidable (i ≤ n)
h : i ≤ n
⊢ ↑(↑(↑(of (fun i => { x // x ∈ A i }) i) r * r') n) = ↑r * ↑(↑r' (n - i))

case inr
ι : Type u_3
σ : Type u_2
S : Type ?u.448211
R : Type u_1
inst✝⁹ : DecidableEq ι
inst✝⁸ : Semiring R
inst✝⁷ : SetLike σ R
inst✝⁶ : AddSubmonoidClass σ R
A : ι → σ
inst✝⁵ : CanonicallyOrderedAddMonoid ι
inst✝⁴ : SetLike.GradedMonoid A
inst✝³ : Sub ι
inst✝² : OrderedSub ι
inst✝¹ : ContravariantClass ι ι (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
i : ι
r : { x // x ∈ A i }
r' : ⨁ (i : ι), { x // x ∈ A i }
n : ι
inst✝ : Decidable (i ≤ n)
h : ¬i ≤ n
⊢ ↑(↑(↑(of (fun i => { x // x ∈ A i }) i) r * r') n) = 0
Theorem: AlternatingMap.map_add_swap
File: Mathlib/LinearAlgebra/Alternating.lean

tactic: rw [add_comm]
state_before: R : Type u_4
inst✝¹⁵ : Semiring R
M : Type u_3
inst✝¹⁴ : AddCommMonoid M
inst✝¹³ : Module R M
N : Type u_2
inst✝¹² : AddCommMonoid N
inst✝¹¹ : Module R N
P : Type ?u.449922
inst✝¹⁰ : AddCommMonoid P
inst✝⁹ : Module R P
M' : Type ?u.449952
inst✝⁸ : AddCommGroup M'
inst✝⁷ : Module R M'
N' : Type ?u.450340
inst✝⁶ : AddCommGroup N'
inst✝⁵ : Module R N'
ι : Type u_1
ι' : Type ?u.450731
ι'' : Type ?u.450734
M₂ : Type ?u.450737
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M₂
M₃ : Type ?u.450767
inst✝² : AddCommMonoid M₃
inst✝¹ : Module R M₃
f f' : AlternatingMap R M N ι
g g₂ : AlternatingMap R M N' ι
g' : AlternatingMap R M' N' ι
v : ι → M
v' : ι → M'
inst✝ : DecidableEq ι
i j : ι
hij : i ≠ j
⊢ ↑f v + ↑f (v ∘ ↑(Equiv.swap i j)) = 0

tactic: exact f.map_swap_add v hij
state_before: R : Type u_4
inst✝¹⁵ : Semiring R
M : Type u_3
inst✝¹⁴ : AddCommMonoid M
inst✝¹³ : Module R M
N : Type u_2
inst✝¹² : AddCommMonoid N
inst✝¹¹ : Module R N
P : Type ?u.449922
inst✝¹⁰ : AddCommMonoid P
inst✝⁹ : Module R P
M' : Type ?u.449952
inst✝⁸ : AddCommGroup M'
inst✝⁷ : Module R M'
N' : Type ?u.450340
inst✝⁶ : AddCommGroup N'
inst✝⁵ : Module R N'
ι : Type u_1
ι' : Type ?u.450731
ι'' : Type ?u.450734
M₂ : Type ?u.450737
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M₂
M₃ : Type ?u.450767
inst✝² : AddCommMonoid M₃
inst✝¹ : Module R M₃
f f' : AlternatingMap R M N ι
g g₂ : AlternatingMap R M N' ι
g' : AlternatingMap R M' N' ι
v : ι → M
v' : ι → M'
inst✝ : DecidableEq ι
i j : ι
hij : i ≠ j
⊢ ↑f (v ∘ ↑(Equiv.swap i j)) + ↑f v = 0
Theorem: OrderIso.image_Ioo
File: Mathlib/Data/Set/Intervals/OrderIso.lean

tactic: rw [e.image_eq_preimage, e.symm.preimage_Ioo, e.symm_symm]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
e : α ≃o β
a b : α
⊢ ↑e '' Ioo a b = Ioo (↑e a) (↑e b)
Theorem: continuous_of_uniform_approx_of_continuous
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: simpa [continuous_iff_continuousOn_univ] using L
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
inst✝ : TopologicalSpace α
L : ∀ (u : Set (β × β)), u ∈ 𝓤 β → ∃ F, Continuous F ∧ ∀ (y : α), (f y, F y) ∈ u
⊢ ∀ (u : Set (β × β)), u ∈ 𝓤 β → ∃ F, ContinuousOn F univ ∧ ∀ (y : α), y ∈ univ → (f y, F y) ∈ u
Theorem: sameRay_smul_right_iff_of_ne
File: Mathlib/LinearAlgebra/Ray.lean

tactic: simp only [sameRay_smul_right_iff, hv, or_false_iff, hr.symm.le_iff_lt]
state_before: R : Type u_2
inst✝³ : LinearOrderedCommRing R
M : Type u_1
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : NoZeroSMulDivisors R M
v : M
hv : v ≠ 0
r : R
hr : r ≠ 0
⊢ SameRay R v (r • v) ↔ 0 < r
Theorem: ComputablePred.to_re
File: Mathlib/Computability/Halting.lean

tactic: obtain ⟨f, hf, rfl⟩ := computable_iff.1 hp
state_before: α : Type u_1
σ : Type ?u.284619
inst✝¹ : Primcodable α
inst✝ : Primcodable σ
p : α → Prop
hp : ComputablePred p
⊢ RePred p

tactic: unfold RePred
state_before: case intro.intro
α : Type u_1
σ : Type ?u.284619
inst✝¹ : Primcodable α
inst✝ : Primcodable σ
f : α → Bool
hf : Computable f
hp : ComputablePred fun a => f a = true
⊢ RePred fun a => f a = true

tactic: dsimp only []
state_before: case intro.intro
α : Type u_1
σ : Type ?u.284619
inst✝¹ : Primcodable α
inst✝ : Primcodable σ
f : α → Bool
hf : Computable f
hp : ComputablePred fun a => f a = true
⊢ Partrec fun a => Part.assert ((fun a => f a = true) a) fun x => Part.some ()

tactic: refine'
  (Partrec.cond hf (Decidable.Partrec.const' (Part.some ())) Partrec.none).of_eq fun n =>
    Part.ext fun a => _
state_before: case intro.intro
α : Type u_1
σ : Type ?u.284619
inst✝¹ : Primcodable α
inst✝ : Primcodable σ
f : α → Bool
hf : Computable f
hp : ComputablePred fun a => f a = true
⊢ Partrec fun a => Part.assert (f a = true) fun x => Part.some ()

tactic: cases a
state_before: case intro.intro
α : Type u_1
σ : Type ?u.284619
inst✝¹ : Primcodable α
inst✝ : Primcodable σ
f : α → Bool
hf : Computable f
hp : ComputablePred fun a => f a = true
n : α
a : Unit
⊢ (a ∈ bif f n then Part.some () else Part.none) ↔ a ∈ Part.assert (f n = true) fun x => Part.some ()

tactic: cases f n <;> simp
state_before: case intro.intro.unit
α : Type u_1
σ : Type ?u.284619
inst✝¹ : Primcodable α
inst✝ : Primcodable σ
f : α → Bool
hf : Computable f
hp : ComputablePred fun a => f a = true
n : α
⊢ (PUnit.unit ∈ bif f n then Part.some () else Part.none) ↔ PUnit.unit ∈ Part.assert (f n = true) fun x => Part.some ()
Theorem: Complex.cos_add
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← cosh_mul_I, add_mul, cosh_add, cosh_mul_I, cosh_mul_I, sinh_mul_I, sinh_mul_I,
  mul_mul_mul_comm, I_mul_I, mul_neg_one, sub_eq_add_neg]
state_before: x y : ℂ
⊢ cos (x + y) = cos x * cos y - sin x * sin y
Theorem: iInf_le_iff
File: Mathlib/Order/CompleteLattice.lean

tactic: simp [iInf, sInf_le_iff, lowerBounds]
state_before: α : Type u_1
β : Type ?u.34572
β₂ : Type ?u.34575
γ : Type ?u.34578
ι : Sort u_2
ι' : Sort ?u.34584
κ : ι → Sort ?u.34589
κ' : ι' → Sort ?u.34594
inst✝ : CompleteSemilatticeInf α
s✝ t : Set α
a b : α
s : ι → α
⊢ iInf s ≤ a ↔ ∀ (b : α), (∀ (i : ι), b ≤ s i) → b ≤ a
Theorem: BoundedContinuousFunction.norm_normComp
File: Mathlib/Topology/ContinuousFunction/Bounded.lean

tactic: simp only [norm_eq, coe_normComp, norm_norm, Function.comp]
state_before: F : Type ?u.1016366
α : Type u
β : Type v
γ : Type w
inst✝¹ : TopologicalSpace α
inst✝ : SeminormedAddCommGroup β
f g : α →ᵇ β
x : α
C : ℝ
⊢ ‖normComp f‖ = ‖f‖
Theorem: Finset.mem_dfinsupp_iff_of_support_subset
File: Mathlib/Data/Dfinsupp/Interval.lean

tactic: refine' mem_dfinsupp_iff.trans (forall_and.symm.trans <| forall_congr' fun i =>
    ⟨ fun h => _,
      fun h => ⟨fun hi => ht <| mem_support_iff.2 fun H => mem_support_iff.1 hi _, fun _ => h⟩⟩)
state_before: ι : Type u_1
α : ι → Type u_2
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (α i)
s : Finset ι
f : Π₀ (i : ι), α i
t✝ : (i : ι) → Finset (α i)
inst✝ : (i : ι) → DecidableEq (α i)
t : Π₀ (i : ι), Finset (α i)
ht : support t ⊆ s
⊢ f ∈ dfinsupp s ↑t ↔ ∀ (i : ι), ↑f i ∈ ↑t i

tactic: by_cases hi : i ∈ s
state_before: case refine'_1
ι : Type u_1
α : ι → Type u_2
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (α i)
s : Finset ι
f : Π₀ (i : ι), α i
t✝ : (i : ι) → Finset (α i)
inst✝ : (i : ι) → DecidableEq (α i)
t : Π₀ (i : ι), Finset (α i)
ht : support t ⊆ s
i : ι
h : (i ∈ support f → i ∈ s) ∧ (i ∈ s → ↑f i ∈ ↑t i)
⊢ ↑f i ∈ ↑t i

tactic: exact h.2 hi
state_before: case pos
ι : Type u_1
α : ι → Type u_2
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (α i)
s : Finset ι
f : Π₀ (i : ι), α i
t✝ : (i : ι) → Finset (α i)
inst✝ : (i : ι) → DecidableEq (α i)
t : Π₀ (i : ι), Finset (α i)
ht : support t ⊆ s
i : ι
h : (i ∈ support f → i ∈ s) ∧ (i ∈ s → ↑f i ∈ ↑t i)
hi : i ∈ s
⊢ ↑f i ∈ ↑t i

tactic: rw [not_mem_support_iff.1 (mt h.1 hi), not_mem_support_iff.1 (not_mem_mono ht hi)]
state_before: case neg
ι : Type u_1
α : ι → Type u_2
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (α i)
s : Finset ι
f : Π₀ (i : ι), α i
t✝ : (i : ι) → Finset (α i)
inst✝ : (i : ι) → DecidableEq (α i)
t : Π₀ (i : ι), Finset (α i)
ht : support t ⊆ s
i : ι
h : (i ∈ support f → i ∈ s) ∧ (i ∈ s → ↑f i ∈ ↑t i)
hi : ¬i ∈ s
⊢ ↑f i ∈ ↑t i

tactic: exact zero_mem_zero
state_before: case neg
ι : Type u_1
α : ι → Type u_2
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (α i)
s : Finset ι
f : Π₀ (i : ι), α i
t✝ : (i : ι) → Finset (α i)
inst✝ : (i : ι) → DecidableEq (α i)
t : Π₀ (i : ι), Finset (α i)
ht : support t ⊆ s
i : ι
h : (i ∈ support f → i ∈ s) ∧ (i ∈ s → ↑f i ∈ ↑t i)
hi : ¬i ∈ s
⊢ 0 ∈ 0

tactic: rwa [H, mem_zero] at h
state_before: case refine'_2
ι : Type u_1
α : ι → Type u_2
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (α i)
s : Finset ι
f : Π₀ (i : ι), α i
t✝ : (i : ι) → Finset (α i)
inst✝ : (i : ι) → DecidableEq (α i)
t : Π₀ (i : ι), Finset (α i)
ht : support t ⊆ s
i : ι
h : ↑f i ∈ ↑t i
hi : i ∈ support f
H : ↑t i = 0
⊢ ↑f i = 0
Theorem: Polynomial.aevalTower_ofId
File: Mathlib/Data/Polynomial/AlgebraMap.lean

tactic: ext
state_before: R : Type u
S : Type v
T : Type w
A : Type z
A' : Type u_1
B' : Type ?u.1575722
a b : R
n : ℕ
inst✝¹⁰ : CommSemiring A'
inst✝⁹ : Semiring B'
inst✝⁸ : CommSemiring R
p q : R[X]
inst✝⁷ : Semiring A
inst✝⁶ : Algebra R A
B : Type ?u.1575935
inst✝⁵ : Semiring B
inst✝⁴ : Algebra R B
x : A
inst✝³ : CommSemiring S
inst✝² : Algebra S R
inst✝¹ : Algebra S A'
inst✝ : Algebra S B'
g : R →ₐ[S] A'
y : A'
⊢ aevalTower (Algebra.ofId S A') = aeval

tactic: simp only [aeval_X, aevalTower_X]
state_before: case h.h
R : Type u
S : Type v
T : Type w
A : Type z
A' : Type u_1
B' : Type ?u.1575722
a b : R
n : ℕ
inst✝¹⁰ : CommSemiring A'
inst✝⁹ : Semiring B'
inst✝⁸ : CommSemiring R
p q : R[X]
inst✝⁷ : Semiring A
inst✝⁶ : Algebra R A
B : Type ?u.1575935
inst✝⁵ : Semiring B
inst✝⁴ : Algebra R B
x : A
inst✝³ : CommSemiring S
inst✝² : Algebra S R
inst✝¹ : Algebra S A'
inst✝ : Algebra S B'
g : R →ₐ[S] A'
y x✝ : A'
⊢ ↑(aevalTower (Algebra.ofId S A') x✝) X = ↑(aeval x✝) X
Theorem: mem_leftCoset_leftCoset
File: Mathlib/GroupTheory/Coset.lean

tactic: rw [← SetLike.mem_coe, ← ha]
state_before: α : Type u_1
inst✝ : Monoid α
s : Submonoid α
a : α
ha : a *l ↑s = ↑s
⊢ a ∈ s

tactic: exact mem_own_leftCoset s a
state_before: α : Type u_1
inst✝ : Monoid α
s : Submonoid α
a : α
ha : a *l ↑s = ↑s
⊢ a ∈ a *l ↑s
Theorem: UniqueFactorizationMonoid.no_factors_of_no_prime_factors
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: simp only [zero_dvd_iff]
state_before: α : Type ?u.938840
R : Type u_1
inst✝¹ : CancelCommMonoidWithZero R
inst✝ : UniqueFactorizationMonoid R
a b : R
ha : a ≠ 0
h : ∀ {d : R}, d ∣ a → d ∣ b → ¬Prime d
d : R
⊢ 0 ∣ a → 0 ∣ b → IsUnit 0

tactic: intros
state_before: α : Type ?u.938840
R : Type u_1
inst✝¹ : CancelCommMonoidWithZero R
inst✝ : UniqueFactorizationMonoid R
a b : R
ha : a ≠ 0
h : ∀ {d : R}, d ∣ a → d ∣ b → ¬Prime d
d : R
⊢ a = 0 → b = 0 → IsUnit 0

tactic: contradiction
state_before: α : Type ?u.938840
R : Type u_1
inst✝¹ : CancelCommMonoidWithZero R
inst✝ : UniqueFactorizationMonoid R
a b : R
ha : a ≠ 0
h : ∀ {d : R}, d ∣ a → d ∣ b → ¬Prime d
d : R
a✝¹ : a = 0
a✝ : b = 0
⊢ IsUnit 0
Theorem: Encodable.decode_list_succ
File: Mathlib/Logic/Equiv/List.lean

tactic: cases' e : unpair v with v₁ v₂
state_before: α : Type u_1
inst✝ : Encodable α
v : ℕ
⊢ decodeList (succ v) = Seq.seq ((fun x x_1 => x :: x_1) <$> decode (unpair v).fst) fun x => decode (unpair v).snd

tactic: simp [decodeList, e]
state_before: case mk
α : Type u_1
inst✝ : Encodable α
v v₁ v₂ : ℕ
e : unpair v = (v₁, v₂)
⊢ decodeList (succ v) = Seq.seq ((fun x x_1 => x :: x_1) <$> decode (v₁, v₂).fst) fun x => decode (v₁, v₂).snd

tactic: rfl
state_before: case mk
α : Type u_1
inst✝ : Encodable α
v v₁ v₂ : ℕ
e : unpair v = (v₁, v₂)
⊢ (Seq.seq (Option.map (fun x x_1 => x :: x_1) (decode v₁)) fun x => decodeList v₂) =
    Seq.seq (Option.map (fun x x_1 => x :: x_1) (decode v₁)) fun x => decode v₂
Theorem: Nat.any_eq_anyTR
File: src/lean/Init/Data/Nat/Basic.lean

tactic: simp [anyTR.loop]
state_before: f : Nat → Bool
n✝ n : Nat
⊢ (any f n || anyTR.loop f (0 + n) 0) = any f (0 + n)

tactic: rw [anyTR.loop, add_sub_self_left, ← Bool.or_assoc, succ_add]
state_before: f : Nat → Bool
n✝ m n : Nat
⊢ (any f n || anyTR.loop f (succ m + n) (succ m)) = any f (succ m + n)

tactic: exact go m (succ n)
state_before: f : Nat → Bool
n✝ m n : Nat
⊢ (any f n || f n || anyTR.loop f (succ (m + n)) m) = any f (succ (m + n))
Theorem: Set.Ioc_union_Ioc_union_Ioc_cycle
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: rw [Ioc_union_Ioc, Ioc_union_Ioc] <;>
simp [min_le_of_left_le, min_le_of_right_le, le_max_of_le_left, le_max_of_le_right, le_refl,
  min_assoc, max_comm]
state_before: α : Type u_1
β : Type ?u.212863
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
a a₁ a₂ b b₁ b₂ c d : α
⊢ Ioc a b ∪ Ioc b c ∪ Ioc c a = Ioc (min a (min b c)) (max a (max b c))
Theorem: Matrix.cons_vecMulVec
File: Mathlib/Data/Matrix/Notation.lean

tactic: ext i
state_before: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝ : Semiring α
x : α
v : Fin m → α
w : n' → α
⊢ vecMulVec (vecCons x v) w = vecCons (x • w) (vecMulVec v w)

tactic: refine' Fin.cases _ _ i <;> simp [vecMulVec]
state_before: case a.h
α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝ : Semiring α
x : α
v : Fin m → α
w : n' → α
i : Fin (Nat.succ m)
x✝ : n'
⊢ vecMulVec (vecCons x v) w i x✝ = vecCons (x • w) (vecMulVec v w) i x✝
Theorem: LieModuleHom.ker_eq_bot
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: rw [← LieSubmodule.coe_toSubmodule_eq_iff, ker_coeSubmodule, LieSubmodule.bot_coeSubmodule,
  LinearMap.ker_eq_bot, coe_toLinearMap]
state_before: R : Type u
L : Type v
M : Type w
N : Type w₁
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 N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
f : M →ₗ⁅R,L⁆ N
⊢ ker f = ⊥ ↔ Function.Injective ↑f
Theorem: List.get_ofFn
File: Mathlib/Data/List/OfFn.lean

tactic: simp
state_before: α : Type u
n : ℕ
f : Fin n → α
i : Fin (length (ofFn f))
⊢ length (ofFn f) = n

tactic: have := Array.getElem_ofFn f i (by simpa using i.2)
state_before: α : Type u
n : ℕ
f : Fin n → α
i : Fin (length (ofFn f))
⊢ get (ofFn f) i = f (↑(Fin.cast (_ : length (ofFn f) = n)) i)

tactic: cases' i with i hi
state_before: α : Type u
n : ℕ
f : Fin n → α
i : Fin (length (ofFn f))
this : (Array.ofFn f)[↑i] = f { val := ↑i, isLt := (_ : ↑i < n) }
⊢ get (ofFn f) i = f (↑(Fin.cast (_ : length (ofFn f) = n)) i)

tactic: simp only [getElem, Array.get] at this
state_before: case mk
α : Type u
n : ℕ
f : Fin n → α
i : ℕ
hi : i < length (ofFn f)
this :
  (Array.ofFn f)[↑{ val := i, isLt := hi }] =
    f { val := ↑{ val := i, isLt := hi }, isLt := (_ : ↑{ val := i, isLt := hi } < n) }
⊢ get (ofFn f) { val := i, isLt := hi } = f (↑(Fin.cast (_ : length (ofFn f) = n)) { val := i, isLt := hi })

tactic: simp only [Fin.cast_mk]
state_before: case mk
α : Type u
n : ℕ
f : Fin n → α
i : ℕ
hi : i < length (ofFn f)
this :
  get (Array.ofFn f).data { val := i, isLt := (_ : ↑{ val := i, isLt := hi } < Array.size (Array.ofFn f)) } =
    f { val := i, isLt := (_ : ↑{ val := i, isLt := hi } < n) }
⊢ get (ofFn f) { val := i, isLt := hi } = f (↑(Fin.cast (_ : length (ofFn f) = n)) { val := i, isLt := hi })

tactic: rw [← this]
state_before: case mk
α : Type u
n : ℕ
f : Fin n → α
i : ℕ
hi : i < length (ofFn f)
this :
  get (Array.ofFn f).data { val := i, isLt := (_ : ↑{ val := i, isLt := hi } < Array.size (Array.ofFn f)) } =
    f { val := i, isLt := (_ : ↑{ val := i, isLt := hi } < n) }
⊢ get (ofFn f) { val := i, isLt := hi } = f { val := i, isLt := (_ : i < n) }

tactic: congr <;> simp [ofFn]
state_before: case mk
α : Type u
n : ℕ
f : Fin n → α
i : ℕ
hi : i < length (ofFn f)
this :
  get (Array.ofFn f).data { val := i, isLt := (_ : ↑{ val := i, isLt := hi } < Array.size (Array.ofFn f)) } =
    f { val := i, isLt := (_ : ↑{ val := i, isLt := hi } < n) }
⊢ get (ofFn f) { val := i, isLt := hi } =
    get (Array.ofFn f).data { val := i, isLt := (_ : ↑{ val := i, isLt := hi } < Array.size (Array.ofFn f)) }

tactic: simpa using i.2
state_before: α : Type u
n : ℕ
f : Fin n → α
i : Fin (length (ofFn f))
⊢ ↑i < Array.size (Array.ofFn f)
Theorem: Finset.exists_next_right
File: Mathlib/Data/Finset/Lattice.lean

tactic: simpa
state_before: F : Type ?u.378979
α : Type u_1
β : Type ?u.378985
γ : Type ?u.378988
ι : Type ?u.378991
κ : Type ?u.378994
inst✝ : LinearOrder α
s✝ : Finset α
H : Finset.Nonempty s✝
x✝ x : α
s : Finset α
h : ∃ y, y ∈ s ∧ x < y
y : α
hy : y ∈ s ∧ x < y
⊢ y ∈ s ∧ (fun x x_1 => x < x_1) x y

tactic: simp
state_before: F : Type ?u.378979
α : Type u_1
β : Type ?u.378985
γ : Type ?u.378988
ι : Type ?u.378991
κ : Type ?u.378994
inst✝ : LinearOrder α
s✝ : Finset α
H : Finset.Nonempty s✝
x✝ x : α
s : Finset α
h : ∃ y, y ∈ s ∧ x < y
Hne : Finset.Nonempty (filter ((fun x x_1 => x < x_1) x) s)
aux :
  min' (filter ((fun x x_1 => x < x_1) x) s) Hne ∈ s ∧
    (fun x x_1 => x < x_1) x (min' (filter ((fun x x_1 => x < x_1) x) s) Hne)
⊢ x < min' (filter ((fun x x_1 => x < x_1) x) s) Hne

tactic: simpa
state_before: F : Type ?u.378979
α : Type u_1
β : Type ?u.378985
γ : Type ?u.378988
ι : Type ?u.378991
κ : Type ?u.378994
inst✝ : LinearOrder α
s✝ : Finset α
H : Finset.Nonempty s✝
x✝ x : α
s : Finset α
h : ∃ y, y ∈ s ∧ x < y
Hne : Finset.Nonempty (filter ((fun x x_1 => x < x_1) x) s)
aux :
  min' (filter ((fun x x_1 => x < x_1) x) s) Hne ∈ s ∧
    (fun x x_1 => x < x_1) x (min' (filter ((fun x x_1 => x < x_1) x) s) Hne)
z : α
hzs : z ∈ s
hz : x < z
⊢ (fun x x_1 => x < x_1) x z
Theorem: manyOneReducible_refl
File: Mathlib/Computability/Reduce.lean

tactic: simp
state_before: α : Type u_1
inst✝ : Primcodable α
p : α → Prop
⊢ ∀ (a : α), p a ↔ p (id a)
Theorem: measurable_limsup'
File: Mathlib/MeasureTheory/Constructions/BorelSpace/Basic.lean

tactic: simp_rw [hu.toHasBasis.limsup_eq_iInf_iSup]
state_before: α : Type u_4
β : Type ?u.1637981
γ : Type ?u.1637984
γ₂ : Type ?u.1637987
δ : Type u_3
ι✝ : Sort y
s✝ t u✝ : Set α
inst✝¹² : TopologicalSpace α
inst✝¹¹ : MeasurableSpace α
inst✝¹⁰ : BorelSpace α
inst✝⁹ : TopologicalSpace β
inst✝⁸ : MeasurableSpace β
inst✝⁷ : BorelSpace β
inst✝⁶ : TopologicalSpace γ
inst✝⁵ : MeasurableSpace γ
inst✝⁴ : BorelSpace γ
inst✝³ : MeasurableSpace δ
inst✝² : CompleteLinearOrder α
inst✝¹ : OrderTopology α
inst✝ : SecondCountableTopology α
ι : Type u_1
ι' : Type u_2
f : ι → δ → α
u : Filter ι
hf : ∀ (i : ι), Measurable (f i)
p : ι' → Prop
s : ι' → Set ι
hu : HasCountableBasis u p s
hs : ∀ (i : ι'), Set.Countable (s i)
⊢ Measurable fun x => limsup (fun i => f i x) u

tactic: refine' measurable_biInf _ hu.countable _
state_before: α : Type u_4
β : Type ?u.1637981
γ : Type ?u.1637984
γ₂ : Type ?u.1637987
δ : Type u_3
ι✝ : Sort y
s✝ t u✝ : Set α
inst✝¹² : TopologicalSpace α
inst✝¹¹ : MeasurableSpace α
inst✝¹⁰ : BorelSpace α
inst✝⁹ : TopologicalSpace β
inst✝⁸ : MeasurableSpace β
inst✝⁷ : BorelSpace β
inst✝⁶ : TopologicalSpace γ
inst✝⁵ : MeasurableSpace γ
inst✝⁴ : BorelSpace γ
inst✝³ : MeasurableSpace δ
inst✝² : CompleteLinearOrder α
inst✝¹ : OrderTopology α
inst✝ : SecondCountableTopology α
ι : Type u_1
ι' : Type u_2
f : ι → δ → α
u : Filter ι
hf : ∀ (i : ι), Measurable (f i)
p : ι' → Prop
s : ι' → Set ι
hu : HasCountableBasis u p s
hs : ∀ (i : ι'), Set.Countable (s i)
⊢ Measurable fun x => ⨅ (i : ι') (_ : p i), ⨆ (a : ι) (_ : a ∈ s i), f a x

tactic: exact fun i => measurable_biSup _ (hs i) hf
state_before: α : Type u_4
β : Type ?u.1637981
γ : Type ?u.1637984
γ₂ : Type ?u.1637987
δ : Type u_3
ι✝ : Sort y
s✝ t u✝ : Set α
inst✝¹² : TopologicalSpace α
inst✝¹¹ : MeasurableSpace α
inst✝¹⁰ : BorelSpace α
inst✝⁹ : TopologicalSpace β
inst✝⁸ : MeasurableSpace β
inst✝⁷ : BorelSpace β
inst✝⁶ : TopologicalSpace γ
inst✝⁵ : MeasurableSpace γ
inst✝⁴ : BorelSpace γ
inst✝³ : MeasurableSpace δ
inst✝² : CompleteLinearOrder α
inst✝¹ : OrderTopology α
inst✝ : SecondCountableTopology α
ι : Type u_1
ι' : Type u_2
f : ι → δ → α
u : Filter ι
hf : ∀ (i : ι), Measurable (f i)
p : ι' → Prop
s : ι' → Set ι
hu : HasCountableBasis u p s
hs : ∀ (i : ι'), Set.Countable (s i)
⊢ ∀ (i : ι'), Measurable fun x => ⨆ (a : ι) (_ : a ∈ s i), f a x
Theorem: FunLike.coe_fn_eq
File: Mathlib/Data/FunLike/Basic.lean

tactic: cases h
state_before: F : Sort u_3
α : Sort u_1
β : α → Sort u_2
i : FunLike F α β
f g : F
h : f = g
⊢ ↑f = ↑g

tactic: rfl
state_before: case refl
F : Sort u_3
α : Sort u_1
β : α → Sort u_2
i : FunLike F α β
f : F
⊢ ↑f = ↑f