tasksource/leandojo huggingface dataset:
Theorem: Ordinal.range_familyOfBFamily'
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: refine' Set.ext fun a => ⟨_, _⟩
state_before: α : Type u_1
β : Type ?u.275577
γ : Type ?u.275580
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u
r : ι → ι → Prop
inst✝ : IsWellOrder ι r
o : Ordinal
ho : type r = o
f : (a : Ordinal) → a < o → α
⊢ range (familyOfBFamily' r ho f) = brange o f

tactic: rintro ⟨b, rfl⟩
state_before: case refine'_1
α : Type u_1
β : Type ?u.275577
γ : Type ?u.275580
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u
r : ι → ι → Prop
inst✝ : IsWellOrder ι r
o : Ordinal
ho : type r = o
f : (a : Ordinal) → a < o → α
a : α
⊢ a ∈ range (familyOfBFamily' r ho f) → a ∈ brange o f

tactic: apply mem_brange_self
state_before: case refine'_1.intro
α : Type u_1
β : Type ?u.275577
γ : Type ?u.275580
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u
r : ι → ι → Prop
inst✝ : IsWellOrder ι r
o : Ordinal
ho : type r = o
f : (a : Ordinal) → a < o → α
b : ι
⊢ familyOfBFamily' r ho f b ∈ brange o f

tactic: rintro ⟨i, hi, rfl⟩
state_before: case refine'_2
α : Type u_1
β : Type ?u.275577
γ : Type ?u.275580
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u
r : ι → ι → Prop
inst✝ : IsWellOrder ι r
o : Ordinal
ho : type r = o
f : (a : Ordinal) → a < o → α
a : α
⊢ a ∈ brange o f → a ∈ range (familyOfBFamily' r ho f)

tactic: exact ⟨_, familyOfBFamily'_enum _ _ _ _ _⟩
state_before: case refine'_2.intro.intro
α : Type u_1
β : Type ?u.275577
γ : Type ?u.275580
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u
r : ι → ι → Prop
inst✝ : IsWellOrder ι r
o : Ordinal
ho : type r = o
f : (a : Ordinal) → a < o → α
i : Ordinal
hi : i < o
⊢ f i hi ∈ range (familyOfBFamily' r ho f)
Theorem: Nat.bit1_div_bit0
File: Mathlib/Data/Nat/Parity.lean

tactic: rw [bit0_eq_two_mul, ← Nat.div_div_eq_div_mul, bit1_div_two]
state_before: m n : ℕ
⊢ bit1 n / bit0 m = n / m
Theorem: Nat.ceil_add_nat
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [← not_lt, ← not_lt, not_iff_not, lt_ceil]
state_before: F : Type ?u.86599
α : Type u_1
β : Type ?u.86605
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n✝ : ℕ
ha : 0 ≤ a
n b : ℕ
⊢ ⌈a + ↑n⌉₊ ≤ b ↔ ⌈a⌉₊ + n ≤ b

tactic: obtain hb | hb := le_or_lt n b
state_before: F : Type ?u.86599
α : Type u_1
β : Type ?u.86605
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n✝ : ℕ
ha : 0 ≤ a
n b : ℕ
⊢ ↑b < a + ↑n ↔ b < ⌈a⌉₊ + n

tactic: obtain ⟨d, rfl⟩ := exists_add_of_le hb
state_before: case inl
F : Type ?u.86599
α : Type u_1
β : Type ?u.86605
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n✝ : ℕ
ha : 0 ≤ a
n b : ℕ
hb : n ≤ b
⊢ ↑b < a + ↑n ↔ b < ⌈a⌉₊ + n

tactic: rw [Nat.cast_add, add_comm n, add_comm (n : α), add_lt_add_iff_right, add_lt_add_iff_right,
  lt_ceil]
state_before: case inl.intro
F : Type ?u.86599
α : Type u_1
β : Type ?u.86605
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n✝ : ℕ
ha : 0 ≤ a
n d : ℕ
hb : n ≤ n + d
⊢ ↑(n + d) < a + ↑n ↔ n + d < ⌈a⌉₊ + n

tactic: exact iff_of_true (lt_add_of_nonneg_of_lt ha <| cast_lt.2 hb) (lt_add_left _ _ _ hb)
state_before: case inr
F : Type ?u.86599
α : Type u_1
β : Type ?u.86605
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n✝ : ℕ
ha : 0 ≤ a
n b : ℕ
hb : b < n
⊢ ↑b < a + ↑n ↔ b < ⌈a⌉₊ + n
Theorem: Fin.cycleRange_of_lt
File: Mathlib/GroupTheory/Perm/Fin.lean

tactic: rw [cycleRange_of_le h.le, if_neg h.ne]
state_before: n : ℕ
i j : Fin (Nat.succ n)
h : j < i
⊢ ↑(cycleRange i) j = j + 1
Theorem: dist_pos
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: simpa only [not_le] using not_congr dist_le_zero
state_before: α : Type u
β : Type v
X : Type ?u.550856
ι : Type ?u.550859
inst✝¹ : PseudoMetricSpace α
γ : Type w
inst✝ : MetricSpace γ
x y : γ
⊢ 0 < dist x y ↔ x ≠ y
Theorem: and_and_right
File: Std/Logic.lean

tactic: rw [and_and_and_comm, and_self]
state_before: a b c : Prop
⊢ (a ∧ b) ∧ c ↔ (a ∧ c) ∧ b ∧ c
Theorem: Finset.sup_sdiff_right
File: Mathlib/Data/Finset/Lattice.lean

tactic: refine' Finset.cons_induction_on s _ fun b t _ h => _
state_before: F : Type ?u.61757
α✝ : Type ?u.61760
β✝ : Type ?u.61763
γ : Type ?u.61766
ι : Type ?u.61769
κ : Type ?u.61772
inst✝² : SemilatticeSup α✝
inst✝¹ : OrderBot α✝
s✝ s₁ s₂ : Finset β✝
f✝ g : β✝ → α✝
a✝ : α✝
α : Type u_1
β : Type u_2
inst✝ : GeneralizedBooleanAlgebra α
s : Finset β
f : β → α
a : α
⊢ (sup s fun b => f b \ a) = sup s f \ a

tactic: rw [sup_empty, sup_empty, bot_sdiff]
state_before: case refine'_1
F : Type ?u.61757
α✝ : Type ?u.61760
β✝ : Type ?u.61763
γ : Type ?u.61766
ι : Type ?u.61769
κ : Type ?u.61772
inst✝² : SemilatticeSup α✝
inst✝¹ : OrderBot α✝
s✝ s₁ s₂ : Finset β✝
f✝ g : β✝ → α✝
a✝ : α✝
α : Type u_1
β : Type u_2
inst✝ : GeneralizedBooleanAlgebra α
s : Finset β
f : β → α
a : α
⊢ (sup ∅ fun b => f b \ a) = sup ∅ f \ a

tactic: rw [sup_cons, sup_cons, h, sup_sdiff]
state_before: case refine'_2
F : Type ?u.61757
α✝ : Type ?u.61760
β✝ : Type ?u.61763
γ : Type ?u.61766
ι : Type ?u.61769
κ : Type ?u.61772
inst✝² : SemilatticeSup α✝
inst✝¹ : OrderBot α✝
s✝ s₁ s₂ : Finset β✝
f✝ g : β✝ → α✝
a✝ : α✝
α : Type u_1
β : Type u_2
inst✝ : GeneralizedBooleanAlgebra α
s : Finset β
f : β → α
a : α
b : β
t : Finset β
x✝ : ¬b ∈ t
h : (sup t fun b => f b \ a) = sup t f \ a
⊢ (sup (cons b t x✝) fun b => f b \ a) = sup (cons b t x✝) f \ a
Theorem: Set.Finite.offDiag
File: Mathlib/Data/Set/Finite.lean

tactic: classical
  cases hs
  apply Set.toFinite
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s✝ : Set α
t : Set β
s : Set α
hs : Set.Finite s
⊢ Set.Finite (offDiag s)

tactic: cases hs
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s✝ : Set α
t : Set β
s : Set α
hs : Set.Finite s
⊢ Set.Finite (offDiag s)

tactic: apply Set.toFinite
state_before: case intro
α : Type u
β : Type v
ι : Sort w
γ : Type x
s✝ : Set α
t : Set β
s : Set α
a✝ : Fintype ↑s
⊢ Set.Finite (offDiag s)
Theorem: CharTwo.sum_mul_self
File: Mathlib/Algebra/CharP/Two.lean

tactic: simp_rw [← pow_two, sum_sq]
state_before: R : Type u_2
ι : Type u_1
inst✝¹ : CommSemiring R
inst✝ : CharP R 2
s : Finset ι
f : ι → R
⊢ (∑ i in s, f i) * ∑ i in s, f i = ∑ i in s, f i * f i
Theorem: MeasureTheory.Measure.toOuterMeasure_le
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [← μ₂.trimmed, OuterMeasure.le_trim_iff]
state_before: α : Type u_1
β : Type ?u.143928
γ : Type ?u.143931
δ : Type ?u.143934
ι : Type ?u.143937
R : Type ?u.143940
R' : Type ?u.143943
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
⊢ ↑μ₁ ≤ ↑μ₂ ↔ μ₁ ≤ μ₂

tactic: rfl
state_before: α : Type u_1
β : Type ?u.143928
γ : Type ?u.143931
δ : Type ?u.143934
ι : Type ?u.143937
R : Type ?u.143940
R' : Type ?u.143943
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
⊢ (∀ (s : Set α), MeasurableSet s → ↑↑μ₁ s ≤ ↑↑μ₂ s) ↔ μ₁ ≤ μ₂
Theorem: Ordering.swap_inj
File: Std/Classes/Order.lean

tactic: simpa using congrArg swap h
state_before: o₁ o₂ : Ordering
h : swap o₁ = swap o₂
⊢ o₁ = o₂
Theorem: IsCoprime.add_mul_right_right
File: Mathlib/RingTheory/Coprime/Basic.lean

tactic: rw [isCoprime_comm]
state_before: R : Type u
inst✝ : CommRing R
x y : R
h : IsCoprime x y
z : R
⊢ IsCoprime x (y + z * x)

tactic: exact h.symm.add_mul_right_left z
state_before: R : Type u
inst✝ : CommRing R
x y : R
h : IsCoprime x y
z : R
⊢ IsCoprime (y + z * x) x
Theorem: Finsupp.addHom_ext
File: Mathlib/Data/Finsupp/Defs.lean

tactic: refine' AddMonoidHom.eq_of_eqOn_denseM add_closure_setOf_eq_single _
state_before: α : Type u_3
β : Type ?u.328659
γ : Type ?u.328662
ι : Type ?u.328665
M : Type u_2
M' : Type ?u.328671
N : Type u_1
P : Type ?u.328677
G : Type ?u.328680
H✝ : Type ?u.328683
R : Type ?u.328686
S : Type ?u.328689
inst✝¹ : AddZeroClass M
inst✝ : AddZeroClass N
f g : (α →₀ M) →+ N
H : ∀ (x : α) (y : M), ↑f (single x y) = ↑g (single x y)
⊢ f = g

tactic: rintro _ ⟨x, y, rfl⟩
state_before: α : Type u_3
β : Type ?u.328659
γ : Type ?u.328662
ι : Type ?u.328665
M : Type u_2
M' : Type ?u.328671
N : Type u_1
P : Type ?u.328677
G : Type ?u.328680
H✝ : Type ?u.328683
R : Type ?u.328686
S : Type ?u.328689
inst✝¹ : AddZeroClass M
inst✝ : AddZeroClass N
f g : (α →₀ M) →+ N
H : ∀ (x : α) (y : M), ↑f (single x y) = ↑g (single x y)
⊢ Set.EqOn ↑f ↑g {f | ∃ a b, f = single a b}

tactic: apply H
state_before: case intro.intro
α : Type u_3
β : Type ?u.328659
γ : Type ?u.328662
ι : Type ?u.328665
M : Type u_2
M' : Type ?u.328671
N : Type u_1
P : Type ?u.328677
G : Type ?u.328680
H✝ : Type ?u.328683
R : Type ?u.328686
S : Type ?u.328689
inst✝¹ : AddZeroClass M
inst✝ : AddZeroClass N
f g : (α →₀ M) →+ N
H : ∀ (x : α) (y : M), ↑f (single x y) = ↑g (single x y)
x : α
y : M
⊢ ↑f (single x y) = ↑g (single x y)
Theorem: Complex.UnitDisc.normSq_lt_one
File: Mathlib/Analysis/Complex/UnitDisc/Basic.lean

tactic: convert (Real.sqrt_lt' one_pos).1 z.abs_lt_one
state_before: z : 𝔻
⊢ ↑normSq ↑z < 1

tactic: exact (one_pow 2).symm
state_before: case h.e'_4
z : 𝔻
⊢ 1 = 1 ^ 2
Theorem: Subgroup.zpowers_le
File: Mathlib/GroupTheory/Subgroup/ZPowers.lean

tactic: rw [zpowers_eq_closure, closure_le, Set.singleton_subset_iff, SetLike.mem_coe]
state_before: G : Type u_1
inst✝² : Group G
A : Type ?u.38467
inst✝¹ : AddGroup A
N : Type ?u.38473
inst✝ : Group N
s : Set G
g✝ g : G
H : Subgroup G
⊢ zpowers g ≤ H ↔ g ∈ H
Theorem: CommRingCat.pushoutCocone_inl
File: Mathlib/Algebra/Category/Ring/Constructions.lean

tactic: letI := f.toAlgebra
state_before: R A B : CommRingCat
f : R ⟶ A
g : R ⟶ B
⊢ A ⟶ (pushoutCocone f g).pt

tactic: letI := g.toAlgebra
state_before: R A B : CommRingCat
f : R ⟶ A
g : R ⟶ B
this : Algebra ↑R ↑A := RingHom.toAlgebra f
⊢ A ⟶ (pushoutCocone f g).pt

tactic: exact Algebra.TensorProduct.includeLeft.toRingHom
state_before: R A B : CommRingCat
f : R ⟶ A
g : R ⟶ B
this✝ : Algebra ↑R ↑A := RingHom.toAlgebra f
this : Algebra ↑R ↑B := RingHom.toAlgebra g
⊢ A ⟶ (pushoutCocone f g).pt
Theorem: List.length_sublistsLen
File: Mathlib/Data/List/Sublists.lean

tactic: simp
state_before: α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
l : List α
⊢ length (sublistsLen 0 l) = Nat.choose (length l) 0

tactic: simp
state_before: α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
n✝ : ℕ
⊢ length (sublistsLen (n✝ + 1) []) = Nat.choose (length []) (n✝ + 1)

tactic: rw [sublistsLen_succ_cons, length_append, length_sublistsLen (n+1) l,
  length_map, length_sublistsLen n l, length_cons, Nat.choose_succ_succ, add_comm]
state_before: α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
n : ℕ
a : α
l : List α
⊢ length (sublistsLen (n + 1) (a :: l)) = Nat.choose (length (a :: l)) (n + 1)
Theorem: List.toFinset_eq_iff_perm_dedup
File: Mathlib/Data/Finset/Basic.lean

tactic: simp [Finset.ext_iff, perm_ext (nodup_dedup _) (nodup_dedup _)]
state_before: α : Type u_1
β : Type ?u.462450
γ : Type ?u.462453
inst✝ : DecidableEq α
l l' : List α
a : α
⊢ toFinset l = toFinset l' ↔ dedup l ~ dedup l'
Theorem: GroupFilterBasis.N_one
File: Mathlib/Topology/Algebra/FilterBasis.lean

tactic: simp only [N, one_mul, map_id']
state_before: G : Type u
inst✝ : Group G
B✝ B : GroupFilterBasis G
⊢ N B 1 = FilterBasis.filter toFilterBasis
Theorem: List.prefix_of_prefix_length_le
File: Std/Data/List/Lemmas.lean

tactic: injection e with _ e'
state_before: α : Type u_1
a : α
l₁ : List α
b : α
l₂ r₁ r₂ : List α
e : b :: l₂ ++ r₂ = a :: l₁ ++ r₁
ll : length (a :: l₁) ≤ length (b :: l₂)
⊢ a :: l₁ <+: b :: l₂

tactic: subst b
state_before: α : Type u_1
a : α
l₁ : List α
b : α
l₂ r₁ r₂ : List α
ll : length (a :: l₁) ≤ length (b :: l₂)
head_eq✝ : b = a
e' : List.append l₂ r₂ = List.append l₁ r₁
⊢ a :: l₁ <+: b :: l₂

tactic: rcases prefix_of_prefix_length_le ⟨_, rfl⟩ ⟨_, e'⟩ (le_of_succ_le_succ ll) with ⟨r₃, rfl⟩
state_before: α : Type u_1
a : α
l₁ l₂ r₁ r₂ : List α
e' : List.append l₂ r₂ = List.append l₁ r₁
ll : length (a :: l₁) ≤ length (a :: l₂)
⊢ a :: l₁ <+: a :: l₂

tactic: exact ⟨r₃, rfl⟩
state_before: case intro
α : Type u_1
a : α
l₁ r₁ r₂ r₃ : List α
e' : List.append (l₁ ++ r₃) r₂ = List.append l₁ r₁
ll : length (a :: l₁) ≤ length (a :: (l₁ ++ r₃))
⊢ a :: l₁ <+: a :: (l₁ ++ r₃)
Theorem: skewAdjoint.conjugate'
File: Mathlib/Algebra/Star/SelfAdjoint.lean

tactic: simp only [mem_iff, star_mul, star_star, mem_iff.mp hx, neg_mul, mul_neg, mul_assoc]
state_before: R : Type u_1
A : Type ?u.111600
inst✝¹ : Ring R
inst✝ : StarRing R
x : R
hx : x ∈ skewAdjoint R
z : R
⊢ star z * x * z ∈ skewAdjoint R
Theorem: IsSelfAdjoint.conjugate
File: Mathlib/Algebra/Star/SelfAdjoint.lean

tactic: simp only [isSelfAdjoint_iff, star_mul, star_star, mul_assoc, hx.star_eq]
state_before: R : Type u_1
A : Type ?u.18062
inst✝¹ : Semigroup R
inst✝ : StarSemigroup R
x : R
hx : IsSelfAdjoint x
z : R
⊢ IsSelfAdjoint (z * x * star z)
Theorem: PiLp.nndist_equiv_symm_single_same
File: Mathlib/Analysis/NormedSpace/PiLp.lean

tactic: rw [nndist_eq_nnnorm, nndist_eq_nnnorm, ← equiv_symm_sub, ← Pi.single_sub,
  nnnorm_equiv_symm_single]
state_before: p : ℝ≥0∞
𝕜 : Type ?u.488127
𝕜' : Type ?u.488130
ι : Type u_1
α : ι → Type ?u.488138
β : ι → Type u_2
inst✝⁹ : Fintype ι
inst✝⁸ : Fact (1 ≤ p)
inst✝⁷ : NormedField 𝕜
inst✝⁶ : NormedField 𝕜'
inst✝⁵ : (i : ι) → SeminormedAddCommGroup (β i)
inst✝⁴ : (i : ι) → NormedSpace 𝕜 (β i)
c : 𝕜
x y : PiLp p β
x' y' : (i : ι) → β i
i✝ : ι
ι' : Type ?u.488339
inst✝³ : Fintype ι'
E : Type ?u.488345
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : DecidableEq ι
i : ι
b₁ b₂ : β i
⊢ nndist (↑(PiLp.equiv p β).symm (Pi.single i b₁)) (↑(PiLp.equiv p β).symm (Pi.single i b₂)) = nndist b₁ b₂
Theorem: Ideal.ideal_prod_eq
File: Mathlib/RingTheory/Ideal/Prod.lean

tactic: apply Ideal.ext
state_before: R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I✝ I' : Ideal R
J J' : Ideal S
I : Ideal (R × S)
⊢ I = prod (map (RingHom.fst R S) I) (map (RingHom.snd R S) I)

tactic: rintro ⟨r, s⟩
state_before: case h
R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I✝ I' : Ideal R
J J' : Ideal S
I : Ideal (R × S)
⊢ ∀ (x : R × S), x ∈ I ↔ x ∈ prod (map (RingHom.fst R S) I) (map (RingHom.snd R S) I)

tactic: rw [mem_prod, mem_map_iff_of_surjective (RingHom.fst R S) Prod.fst_surjective,
  mem_map_iff_of_surjective (RingHom.snd R S) Prod.snd_surjective]
state_before: case h.mk
R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I✝ I' : Ideal R
J J' : Ideal S
I : Ideal (R × S)
r : R
s : S
⊢ (r, s) ∈ I ↔ (r, s) ∈ prod (map (RingHom.fst R S) I) (map (RingHom.snd R S) I)

tactic: refine' ⟨fun h => ⟨⟨_, ⟨h, rfl⟩⟩, ⟨_, ⟨h, rfl⟩⟩⟩, _⟩
state_before: case h.mk
R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I✝ I' : Ideal R
J J' : Ideal S
I : Ideal (R × S)
r : R
s : S
⊢ (r, s) ∈ I ↔ (∃ x, x ∈ I ∧ ↑(RingHom.fst R S) x = r) ∧ ∃ x, x ∈ I ∧ ↑(RingHom.snd R S) x = s

tactic: rintro ⟨⟨⟨r, s'⟩, ⟨h₁, rfl⟩⟩, ⟨⟨r', s⟩, ⟨h₂, rfl⟩⟩⟩
state_before: case h.mk
R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I✝ I' : Ideal R
J J' : Ideal S
I : Ideal (R × S)
r : R
s : S
⊢ ((∃ x, x ∈ I ∧ ↑(RingHom.fst R S) x = r) ∧ ∃ x, x ∈ I ∧ ↑(RingHom.snd R S) x = s) → (r, s) ∈ I

tactic: simpa using I.add_mem (I.mul_mem_left (1, 0) h₁) (I.mul_mem_left (0, 1) h₂)
state_before: case h.mk.intro.intro.mk.intro.intro.mk.intro
R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I✝ I' : Ideal R
J J' : Ideal S
I : Ideal (R × S)
r : R
s' : S
h₁ : (r, s') ∈ I
r' : R
s : S
h₂ : (r', s) ∈ I
⊢ (↑(RingHom.fst R S) (r, s'), ↑(RingHom.snd R S) (r', s)) ∈ I
Theorem: Fin.Ioi_zero_eq_map
File: Mathlib/Data/Fintype/Fin.lean

tactic: ext i
state_before: α : Type ?u.5462
β : Type ?u.5465
n : ℕ
⊢ Ioi 0 = map (succEmbedding n).toEmbedding univ

tactic: simp only [mem_Ioi, mem_map, mem_univ, Function.Embedding.coeFn_mk, exists_true_left]
state_before: case a
α : Type ?u.5462
β : Type ?u.5465
n : ℕ
i : Fin (Nat.succ n)
⊢ i ∈ Ioi 0 ↔ i ∈ map (succEmbedding n).toEmbedding univ

tactic: constructor
state_before: case a
α : Type ?u.5462
β : Type ?u.5465
n : ℕ
i : Fin (Nat.succ n)
⊢ 0 < i ↔ ∃ a, True ∧ ↑(succEmbedding n).toEmbedding a = i

tactic: refine' cases _ _ i
state_before: case a.mp
α : Type ?u.5462
β : Type ?u.5465
n : ℕ
i : Fin (Nat.succ n)
⊢ 0 < i → ∃ a, True ∧ ↑(succEmbedding n).toEmbedding a = i

tactic: rintro ⟨⟨⟩⟩
state_before: case a.mp.refine'_1
α : Type ?u.5462
β : Type ?u.5465
n : ℕ
i : Fin (Nat.succ n)
⊢ 0 < 0 → ∃ a, True ∧ ↑(succEmbedding n).toEmbedding a = 0

tactic: intro j _
state_before: case a.mp.refine'_2
α : Type ?u.5462
β : Type ?u.5465
n : ℕ
i : Fin (Nat.succ n)
⊢ ∀ (i : Fin n), 0 < succ i → ∃ a, True ∧ ↑(succEmbedding n).toEmbedding a = succ i

tactic: use j
state_before: case a.mp.refine'_2
α : Type ?u.5462
β : Type ?u.5465
n : ℕ
i : Fin (Nat.succ n)
j : Fin n
a✝ : 0 < succ j
⊢ ∃ a, True ∧ ↑(succEmbedding n).toEmbedding a = succ j

tactic: simp only [val_succEmbedding, and_self, RelEmbedding.coe_toEmbedding]
state_before: case a.mp.refine'_2
α : Type ?u.5462
β : Type ?u.5465
n : ℕ
i : Fin (Nat.succ n)
j : Fin n
a✝ : 0 < succ j
⊢ True ∧ ↑(succEmbedding n).toEmbedding j = succ j

tactic: rintro ⟨i, _, rfl⟩
state_before: case a.mpr
α : Type ?u.5462
β : Type ?u.5465
n : ℕ
i : Fin (Nat.succ n)
⊢ (∃ a, True ∧ ↑(succEmbedding n).toEmbedding a = i) → 0 < i

tactic: exact succ_pos _
state_before: case a.mpr.intro.intro
α : Type ?u.5462
β : Type ?u.5465
n : ℕ
i : Fin n
left✝ : True
⊢ 0 < ↑(succEmbedding n).toEmbedding i
Theorem: Set.apply_piecewise₂
File: Mathlib/Data/Set/Function.lean

tactic: by_cases hx : x ∈ s <;> simp [hx]
state_before: α : Type u_3
β : Type ?u.91797
γ : Type ?u.91800
ι : Sort ?u.91803
π : α → Type ?u.91808
δ : α → Sort u_4
s : Set α
f g : (i : α) → δ i
inst✝ : (j : α) → Decidable (j ∈ s)
δ' : α → Sort u_1
δ'' : α → Sort u_2
f' g' : (i : α) → δ' i
h : (i : α) → δ i → δ' i → δ'' i
x : α
⊢ h x (piecewise s f g x) (piecewise s f' g' x) = piecewise s (fun x => h x (f x) (f' x)) (fun x => h x (g x) (g' x)) x
Theorem: Stream'.WSeq.toList_cons
File: Mathlib/Data/Seq/WSeq.lean

tactic: unfold toList
state_before: α : Type u
β : Type v
γ : Type w
a : α
s : WSeq α
⊢ Computation.destruct (toList (cons a s)) = Sum.inr (List.cons a <$> toList s)

tactic: simp
state_before: α : Type u
β : Type v
γ : Type w
a : α
s : WSeq α
⊢ Computation.destruct
      (Computation.corec
        (fun x =>
          match x with
          | (l, s) =>
            match Seq.destruct s with
            | none => Sum.inl (List.reverse l)
            | some (none, s') => Sum.inr (l, s')
            | some (some a, s') => Sum.inr (a :: l, s'))
        ([], cons a s)) =
    Sum.inr
      (List.cons a <$>
        Computation.corec
          (fun x =>
            match x with
            | (l, s) =>
              match Seq.destruct s with
              | none => Sum.inl (List.reverse l)
              | some (none, s') => Sum.inr (l, s')
              | some (some a, s') => Sum.inr (a :: l, s'))
          ([], s))

tactic: rw [toList'_map]
state_before: α : Type u
β : Type v
γ : Type w
a : α
s : WSeq α
⊢ Computation.corec
      (fun x =>
        match Seq.destruct x.snd with
        | none => Sum.inl (List.reverse x.fst)
        | some (none, s') => Sum.inr (x.fst, s')
        | some (some a, s') => Sum.inr (a :: x.fst, s'))
      ([a], s) =
    List.cons a <$>
      Computation.corec
        (fun x =>
          match Seq.destruct x.snd with
          | none => Sum.inl (List.reverse x.fst)
          | some (none, s') => Sum.inr (x.fst, s')
          | some (some a, s') => Sum.inr (a :: x.fst, s'))
        ([], s)

tactic: simp
state_before: α : Type u
β : Type v
γ : Type w
a : α
s : WSeq α
⊢ (fun x x_1 => x ++ x_1) (List.reverse [a]) <$> toList s =
    List.cons a <$>
      Computation.corec
        (fun x =>
          match Seq.destruct x.snd with
          | none => Sum.inl (List.reverse x.fst)
          | some (none, s') => Sum.inr (x.fst, s')
          | some (some a, s') => Sum.inr (a :: x.fst, s'))
        ([], s)

tactic: rfl
state_before: α : Type u
β : Type v
γ : Type w
a : α
s : WSeq α
⊢ (fun x => a :: x) <$> toList s =
    List.cons a <$>
      Computation.corec
        (fun x =>
          match Seq.destruct x.snd with
          | none => Sum.inl (List.reverse x.fst)
          | some (none, s') => Sum.inr (x.fst, s')
          | some (some a, s') => Sum.inr (a :: x.fst, s'))
        ([], s)
Theorem: half_add_self
File: Mathlib/Algebra/CharZero/Lemmas.lean

tactic: rw [← mul_two, mul_div_cancel a two_ne_zero]
state_before: R : Type u_1
inst✝¹ : DivisionRing R
inst✝ : CharZero R
a : R
⊢ (a + a) / 2 = a
Theorem: MeasureTheory.setToFun_congr_left
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: by_cases hf : Integrable f μ
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1331504
G : Type ?u.1331507
𝕜 : Type ?u.1331510
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
hT : DominatedFinMeasAdditive μ T C
hT' : DominatedFinMeasAdditive μ T' C'
h : T = T'
f : α → E
⊢ setToFun μ T hT f = setToFun μ T' hT' f

tactic: simp_rw [setToFun_eq _ hf, L1.setToL1_congr_left T T' hT hT' h]
state_before: case pos
α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1331504
G : Type ?u.1331507
𝕜 : Type ?u.1331510
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
hT : DominatedFinMeasAdditive μ T C
hT' : DominatedFinMeasAdditive μ T' C'
h : T = T'
f : α → E
hf : Integrable f
⊢ setToFun μ T hT f = setToFun μ T' hT' f

tactic: simp_rw [setToFun_undef _ hf]
state_before: case neg
α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1331504
G : Type ?u.1331507
𝕜 : Type ?u.1331510
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
hT : DominatedFinMeasAdditive μ T C
hT' : DominatedFinMeasAdditive μ T' C'
h : T = T'
f : α → E
hf : ¬Integrable f
⊢ setToFun μ T hT f = setToFun μ T' hT' f
Theorem: isNoetherian_of_submodule_of_noetherian
File: Mathlib/RingTheory/Noetherian.lean

tactic: rw [isNoetherian_iff_wellFounded] at h⊢
state_before: R : Type u_1
M : Type u_2
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
N : Submodule R M
h : IsNoetherian R M
⊢ IsNoetherian R { x // x ∈ N }

tactic: exact OrderEmbedding.wellFounded (Submodule.MapSubtype.orderEmbedding N).dual h
state_before: R : Type u_1
M : Type u_2
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
N : Submodule R M
h : WellFounded fun x x_1 => x > x_1
⊢ WellFounded fun x x_1 => x > x_1
Theorem: AlgebraicTopology.DoldKan.P_f_idem
File: Mathlib/AlgebraicTopology/DoldKan/Projections.lean

tactic: rcases n with (_|n)
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
q n : ℕ
⊢ HomologicalComplex.Hom.f (P q) n ≫ HomologicalComplex.Hom.f (P q) n = HomologicalComplex.Hom.f (P q) n

tactic: rw [P_f_0_eq q, comp_id]
state_before: case zero
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
q : ℕ
⊢ HomologicalComplex.Hom.f (P q) Nat.zero ≫ HomologicalComplex.Hom.f (P q) Nat.zero =
    HomologicalComplex.Hom.f (P q) Nat.zero

tactic: exact (HigherFacesVanish.of_P q n).comp_P_eq_self
state_before: case succ
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
q n : ℕ
⊢ HomologicalComplex.Hom.f (P q) (Nat.succ n) ≫ HomologicalComplex.Hom.f (P q) (Nat.succ n) =
    HomologicalComplex.Hom.f (P q) (Nat.succ n)
Theorem: Matrix.cons_val_fin_one
File: Mathlib/Data/Fin/VecNotation.lean

tactic: rw [Fin.forall_fin_one]
state_before: α : Type u
m n o : ℕ
m' : Type ?u.22598
n' : Type ?u.22601
o' : Type ?u.22604
x : α
u : Fin 0 → α
⊢ ∀ (i : Fin 1), vecCons x u i = x

tactic: rfl
state_before: α : Type u
m n o : ℕ
m' : Type ?u.22598
n' : Type ?u.22601
o' : Type ?u.22604
x : α
u : Fin 0 → α
⊢ vecCons x u 0 = x