tasksource/leandojo huggingface dataset:
Theorem: Nat.floor_congr
File: Mathlib/Algebra/Order/Floor.lean

tactic: have h₀ : 0 ≤ a ↔ 0 ≤ b := by simpa only [cast_zero] using h 0
state_before: F : Type ?u.292175
α : Type u_1
β : Type u_2
inst✝⁴ : LinearOrderedSemiring α
inst✝³ : LinearOrderedSemiring β
inst✝² : FloorSemiring α
inst✝¹ : FloorSemiring β
inst✝ : RingHomClass F α β
a : α
b : β
h : ∀ (n : ℕ), ↑n ≤ a ↔ ↑n ≤ b
⊢ ⌊a⌋₊ = ⌊b⌋₊

tactic: obtain ha | ha := lt_or_le a 0
state_before: F : Type ?u.292175
α : Type u_1
β : Type u_2
inst✝⁴ : LinearOrderedSemiring α
inst✝³ : LinearOrderedSemiring β
inst✝² : FloorSemiring α
inst✝¹ : FloorSemiring β
inst✝ : RingHomClass F α β
a : α
b : β
h : ∀ (n : ℕ), ↑n ≤ a ↔ ↑n ≤ b
h₀ : 0 ≤ a ↔ 0 ≤ b
⊢ ⌊a⌋₊ = ⌊b⌋₊

tactic: exact (le_floor <| (h _).1 <| floor_le ha).antisymm (le_floor <| (h _).2 <| floor_le <| h₀.1 ha)
state_before: case inr
F : Type ?u.292175
α : Type u_1
β : Type u_2
inst✝⁴ : LinearOrderedSemiring α
inst✝³ : LinearOrderedSemiring β
inst✝² : FloorSemiring α
inst✝¹ : FloorSemiring β
inst✝ : RingHomClass F α β
a : α
b : β
h : ∀ (n : ℕ), ↑n ≤ a ↔ ↑n ≤ b
h₀ : 0 ≤ a ↔ 0 ≤ b
ha : 0 ≤ a
⊢ ⌊a⌋₊ = ⌊b⌋₊

tactic: simpa only [cast_zero] using h 0
state_before: F : Type ?u.292175
α : Type u_1
β : Type u_2
inst✝⁴ : LinearOrderedSemiring α
inst✝³ : LinearOrderedSemiring β
inst✝² : FloorSemiring α
inst✝¹ : FloorSemiring β
inst✝ : RingHomClass F α β
a : α
b : β
h : ∀ (n : ℕ), ↑n ≤ a ↔ ↑n ≤ b
⊢ 0 ≤ a ↔ 0 ≤ b

tactic: rw [floor_of_nonpos ha.le, floor_of_nonpos (le_of_not_le <| h₀.not.mp ha.not_le)]
state_before: case inl
F : Type ?u.292175
α : Type u_1
β : Type u_2
inst✝⁴ : LinearOrderedSemiring α
inst✝³ : LinearOrderedSemiring β
inst✝² : FloorSemiring α
inst✝¹ : FloorSemiring β
inst✝ : RingHomClass F α β
a : α
b : β
h : ∀ (n : ℕ), ↑n ≤ a ↔ ↑n ≤ b
h₀ : 0 ≤ a ↔ 0 ≤ b
ha : a < 0
⊢ ⌊a⌋₊ = ⌊b⌋₊
Theorem: Int.add_emod_eq_add_emod_left
File: Std/Data/Int/DivMod.lean

tactic: rw [Int.add_comm, add_emod_eq_add_emod_right _ H, Int.add_comm]
state_before: m n k i : Int
H : m % n = k % n
⊢ (i + m) % n = (i + k) % n
Theorem: maximals_union
File: Mathlib/Order/Minimal.lean

tactic: intro a ha
state_before: α : Type u_1
r r₁ r₂ : α → α → Prop
s t : Set α
a b : α
⊢ maximals r (s ∪ t) ⊆ maximals r s ∪ maximals r t

tactic: obtain h | h := ha.1
state_before: α : Type u_1
r r₁ r₂ : α → α → Prop
s t : Set α
a✝ b a : α
ha : a ∈ maximals r (s ∪ t)
⊢ a ∈ maximals r s ∪ maximals r t

tactic: exact Or.inl ⟨h, fun b hb => ha.2 <| Or.inl hb⟩
state_before: case inl
α : Type u_1
r r₁ r₂ : α → α → Prop
s t : Set α
a✝ b a : α
ha : a ∈ maximals r (s ∪ t)
h : a ∈ s
⊢ a ∈ maximals r s ∪ maximals r t

tactic: exact Or.inr ⟨h, fun b hb => ha.2 <| Or.inr hb⟩
state_before: case inr
α : Type u_1
r r₁ r₂ : α → α → Prop
s t : Set α
a✝ b a : α
ha : a ∈ maximals r (s ∪ t)
h : a ∈ t
⊢ a ∈ maximals r s ∪ maximals r t
Theorem: Std.BinomialHeapImp.Heap.realSize_tail
File: Std/Data/BinomialHeap.lean

tactic: simp only [Heap.tail]
state_before: α : Type u_1
le : α → α → Bool
s : Heap α
⊢ realSize (tail le s) = realSize s - 1

tactic: match eq : s.tail? le with
| none => cases s with cases eq | nil => rfl
| some tl => simp [Heap.realSize_tail? eq]; rfl
state_before: α : Type u_1
le : α → α → Bool
s : Heap α
⊢ realSize (Option.getD (tail? le s) nil) = realSize s - 1

tactic: cases s with cases eq | nil => rfl
state_before: α : Type u_1
le : α → α → Bool
s : Heap α
eq : tail? le s = none
⊢ realSize (Option.getD none nil) = realSize s - 1

tactic: rfl
state_before: case nil.refl
α : Type u_1
le : α → α → Bool
⊢ realSize (Option.getD none nil) = realSize nil - 1

tactic: simp [Heap.realSize_tail? eq]
state_before: α : Type u_1
le : α → α → Bool
s tl : Heap α
eq : tail? le s = some tl
⊢ realSize (Option.getD (some tl) nil) = realSize s - 1

tactic: rfl
state_before: α : Type u_1
le : α → α → Bool
s tl : Heap α
eq : tail? le s = some tl
⊢ realSize (Option.getD (some tl) nil) = realSize tl
Theorem: Subgroup.comap_injective_isCommutative
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: have := mul_comm (⟨f a, a.2⟩ : H) (⟨f b, b.2⟩ : H)
state_before: G : Type u_2
G' : Type u_1
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.427007
inst✝¹ : AddGroup A
H K : Subgroup G
f : G' →* G
hf : Injective ↑f
inst✝ : IsCommutative H
a b : { x // x ∈ comap f H }
⊢ ↑(a * b) = ↑(b * a)

tactic: rwa [Subtype.ext_iff, coe_mul, coe_mul, coe_mk, coe_mk, ← map_mul, ← map_mul,
  hf.eq_iff] at this
state_before: G : Type u_2
G' : Type u_1
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.427007
inst✝¹ : AddGroup A
H K : Subgroup G
f : G' →* G
hf : Injective ↑f
inst✝ : IsCommutative H
a b : { x // x ∈ comap f H }
this :
  { val := ↑f ↑a, property := (_ : ↑a ∈ comap f H) } * { val := ↑f ↑b, property := (_ : ↑b ∈ comap f H) } =
    { val := ↑f ↑b, property := (_ : ↑b ∈ comap f H) } * { val := ↑f ↑a, property := (_ : ↑a ∈ comap f H) }
⊢ ↑(a * b) = ↑(b * a)
Theorem: Path.symm_range
File: Mathlib/Topology/PathConnected.lean

tactic: ext x
state_before: X : Type u_1
Y : Type ?u.114634
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type ?u.114649
γ✝ : Path x y
a b : X
γ : Path a b
⊢ range ↑(symm γ) = range ↑γ

tactic: simp only [mem_range, Path.symm, FunLike.coe, unitInterval.symm, SetCoe.exists, comp_apply,
  Subtype.coe_mk]
state_before: case h
X : Type u_1
Y : Type ?u.114634
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x✝ y z : X
ι : Type ?u.114649
γ✝ : Path x✝ y
a b : X
γ : Path a b
x : X
⊢ x ∈ range ↑(symm γ) ↔ x ∈ range ↑γ

tactic: constructor <;> rintro ⟨y, hy, hxy⟩ <;> refine' ⟨1 - y, mem_iff_one_sub_mem.mp hy, _⟩ <;>
  convert hxy
state_before: case h
X : Type u_1
Y : Type ?u.114634
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x✝ y z : X
ι : Type ?u.114649
γ✝ : Path x✝ y
a b : X
γ : Path a b
x : X
⊢ (∃ x_1 h,
      ContinuousMap.toFun γ.toContinuousMap
          { val := 1 - x_1, property := (_ : 1 - ↑{ val := x_1, property := (_ : x_1 ∈ I) } ∈ I) } =
        x) ↔
    ∃ x_1 h, ContinuousMap.toFun γ.toContinuousMap { val := x_1, property := h } = x

tactic: simp
state_before: case h.e'_2.h.e'_6.h.e'_3
X : Type u_1
Y : Type ?u.114634
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x✝ y✝ z : X
ι : Type ?u.114649
γ✝ : Path x✝ y✝
a b : X
γ : Path a b
x : X
y : ℝ
hy : y ∈ I
hxy : ContinuousMap.toFun γ.toContinuousMap { val := y, property := hy } = x
⊢ 1 - (1 - y) = y
Theorem: Ordinal.lt_wf
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: rcases typein_surj r (lt_trans h (typein_lt_type r _)) with ⟨b, rfl⟩
state_before: α✝ : Type ?u.98794
β : Type ?u.98797
γ : Type ?u.98800
r✝ : α✝ → α✝ → Prop
s : β → β → Prop
t : γ → γ → Prop
a✝ : Ordinal
α : Type u_1
r : α → α → Prop
wo : IsWellOrder α r
a x : α
x✝ : ∀ (y : α), r y x → Acc r y
IH : ∀ (y : α), r y x → Acc (fun x x_1 => x < x_1) (typein r y)
o : Ordinal
h : o < typein r x
⊢ Acc (fun x x_1 => x < x_1) o

tactic: exact IH _ ((typein_lt_typein r).1 h)
state_before: case intro
α✝ : Type ?u.98794
β : Type ?u.98797
γ : Type ?u.98800
r✝ : α✝ → α✝ → Prop
s : β → β → Prop
t : γ → γ → Prop
a✝ : Ordinal
α : Type u_1
r : α → α → Prop
wo : IsWellOrder α r
a x : α
x✝ : ∀ (y : α), r y x → Acc r y
IH : ∀ (y : α), r y x → Acc (fun x x_1 => x < x_1) (typein r y)
b : α
h : typein r b < typein r x
⊢ Acc (fun x x_1 => x < x_1) (typein r b)
Theorem: List.getLastD_eq_getLast?
File: Std/Data/List/Lemmas.lean

tactic: cases l <;> rfl
state_before: α : Type u_1
a : α
l : List α
⊢ getLastD l a = Option.getD (getLast? l) a
Theorem: Absorbent.subset
File: Mathlib/Analysis/LocallyConvex/Basic.lean

tactic: refine' forall_imp (fun x => _) hA
state_before: 𝕜 : Type u_1
𝕝 : Type ?u.6565
E : Type u_2
ι : Sort ?u.6571
κ : ι → Sort ?u.6576
inst✝¹ : SeminormedRing 𝕜
inst✝ : SMul 𝕜 E
s t u v A B : Set E
hA : Absorbent 𝕜 A
hAB : A ⊆ B
⊢ Absorbent 𝕜 B

tactic: exact Exists.imp fun r => And.imp_right <| forall₂_imp fun a _ha hx => Set.smul_set_mono hAB hx
state_before: 𝕜 : Type u_1
𝕝 : Type ?u.6565
E : Type u_2
ι : Sort ?u.6571
κ : ι → Sort ?u.6576
inst✝¹ : SeminormedRing 𝕜
inst✝ : SMul 𝕜 E
s t u v A B : Set E
hA : Absorbent 𝕜 A
hAB : A ⊆ B
x : E
⊢ (∃ r, 0 < r ∧ ∀ (a : 𝕜), r ≤ ‖a‖ → x ∈ a • A) → ∃ r, 0 < r ∧ ∀ (a : 𝕜), r ≤ ‖a‖ → x ∈ a • B
Theorem: Finset.card_mul_mul_le_card_div_mul_card_div
File: Mathlib/Combinatorics/Additive/PluenneckeRuzsa.lean

tactic: rw [div_eq_mul_inv, ← card_inv B, ← card_inv (B / C), inv_div', div_inv_eq_mul]
state_before: α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A✝ B✝ C✝ A B C : Finset α
⊢ card (A * C) * card B ≤ card (A / B) * card (B / C)

tactic: exact card_mul_mul_card_le_card_mul_mul_card_mul _ _ _
state_before: α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A✝ B✝ C✝ A B C : Finset α
⊢ card (A * C) * card B⁻¹ ≤ card (A * B⁻¹) * card (B⁻¹ * C)
Theorem: re_inner_eq_norm_mul_self_add_norm_mul_self_sub_norm_sub_mul_self_div_two
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [@norm_sub_mul_self 𝕜]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.2553374
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : E
⊢ ↑re (inner x y) = (‖x‖ * ‖x‖ + ‖y‖ * ‖y‖ - ‖x - y‖ * ‖x - y‖) / 2

tactic: ring
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.2553374
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : E
⊢ ↑re (inner x y) = (‖x‖ * ‖x‖ + ‖y‖ * ‖y‖ - (‖x‖ * ‖x‖ - 2 * ↑re (inner x y) + ‖y‖ * ‖y‖)) / 2
Theorem: Set.ncard_image_le
File: Mathlib/Data/Set/Ncard.lean

tactic: classical
rw [ncard_eq_toFinset_card s hs]
convert @Finset.card_image_le _ _ hs.toFinset f _
simp only
rw [@ncard_eq_toFinset_card _ _ (hs.image f), Finite.toFinset_image]
state_before: α : Type u_1
β : Type u_2
s t : Set α
a b x y : α
f : α → β
hs : autoParam (Set.Finite s) _auto✝
⊢ ncard (f '' s) ≤ ncard s

tactic: rw [ncard_eq_toFinset_card s hs]
state_before: α : Type u_1
β : Type u_2
s t : Set α
a b x y : α
f : α → β
hs : autoParam (Set.Finite s) _auto✝
⊢ ncard (f '' s) ≤ ncard s

tactic: convert @Finset.card_image_le _ _ hs.toFinset f _
state_before: α : Type u_1
β : Type u_2
s t : Set α
a b x y : α
f : α → β
hs : autoParam (Set.Finite s) _auto✝
⊢ ncard (f '' s) ≤ Finset.card (Finite.toFinset hs)

tactic: simp only
state_before: case h.e'_3
α : Type u_1
β : Type u_2
s t : Set α
a b x y : α
f : α → β
hs : autoParam (Set.Finite s) _auto✝
⊢ ncard (f '' s) = Finset.card (Finset.image f (Finite.toFinset hs))

tactic: rw [@ncard_eq_toFinset_card _ _ (hs.image f), Finite.toFinset_image]
state_before: case h.e'_3
α : Type u_1
β : Type u_2
s t : Set α
a b x y : α
f : α → β
hs : autoParam (Set.Finite s) _auto✝
⊢ ncard (f '' s) = Finset.card (Finset.image f (Finite.toFinset hs))
Theorem: BoxIntegral.Prepartition.biUnionIndex_mem
File: Mathlib/Analysis/BoxIntegral/Partition/Basic.lean

tactic: rw [biUnionIndex, dif_pos hJ]
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
hJ : J ∈ biUnion π πi
⊢ biUnionIndex π πi J ∈ π

tactic: exact (π.mem_biUnion.1 hJ).choose_spec.1
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
hJ : J ∈ biUnion π πi
⊢ Exists.choose (_ : ∃ J', J' ∈ π ∧ J ∈ πi J') ∈ π
Theorem: ZFSet.sUnion_singleton
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: simp_rw [mem_sUnion, mem_singleton, exists_eq_left]
state_before: x y : ZFSet
⊢ y ∈ ⋃₀ {x} ↔ y ∈ x
Theorem: MeasurableEmbedding.measurableSet_preimage
File: Mathlib/MeasureTheory/MeasurableSpace.lean

tactic: rw [← image_preimage_eq_inter_range, hf.measurableSet_image]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.380860
δ : Type ?u.380863
δ' : Type ?u.380866
ι : Sort uι
s✝ t u : Set α
mα : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
f : α → β
g : β → γ
hf : MeasurableEmbedding f
s : Set β
⊢ MeasurableSet (f ⁻¹' s) ↔ MeasurableSet (s ∩ range f)
Theorem: LinearOrderedField.cutMap_self
File: Mathlib/Algebra/Order/CompleteField.lean

tactic: ext
state_before: F : Type ?u.9231
α : Type u_1
β : Type ?u.9237
γ : Type ?u.9240
inst✝¹ : LinearOrderedField α
inst✝ : DivisionRing β
a✝ a₁ a₂ : α
b : β
q : ℚ
a : α
⊢ cutMap α a = Iio a ∩ range Rat.cast

tactic: constructor
state_before: case h
F : Type ?u.9231
α : Type u_1
β : Type ?u.9237
γ : Type ?u.9240
inst✝¹ : LinearOrderedField α
inst✝ : DivisionRing β
a✝ a₁ a₂ : α
b : β
q : ℚ
a x✝ : α
⊢ x✝ ∈ cutMap α a ↔ x✝ ∈ Iio a ∩ range Rat.cast

tactic: rintro ⟨q, h, rfl⟩
state_before: case h.mp
F : Type ?u.9231
α : Type u_1
β : Type ?u.9237
γ : Type ?u.9240
inst✝¹ : LinearOrderedField α
inst✝ : DivisionRing β
a✝ a₁ a₂ : α
b : β
q : ℚ
a x✝ : α
⊢ x✝ ∈ cutMap α a → x✝ ∈ Iio a ∩ range Rat.cast

tactic: exact ⟨h, q, rfl⟩
state_before: case h.mp.intro.intro
F : Type ?u.9231
α : Type u_1
β : Type ?u.9237
γ : Type ?u.9240
inst✝¹ : LinearOrderedField α
inst✝ : DivisionRing β
a✝ a₁ a₂ : α
b : β
q✝ : ℚ
a : α
q : ℚ
h : q ∈ {t | ↑t < a}
⊢ ↑q ∈ Iio a ∩ range Rat.cast

tactic: rintro ⟨h, q, rfl⟩
state_before: case h.mpr
F : Type ?u.9231
α : Type u_1
β : Type ?u.9237
γ : Type ?u.9240
inst✝¹ : LinearOrderedField α
inst✝ : DivisionRing β
a✝ a₁ a₂ : α
b : β
q : ℚ
a x✝ : α
⊢ x✝ ∈ Iio a ∩ range Rat.cast → x✝ ∈ cutMap α a

tactic: exact ⟨q, h, rfl⟩
state_before: case h.mpr.intro.intro
F : Type ?u.9231
α : Type u_1
β : Type ?u.9237
γ : Type ?u.9240
inst✝¹ : LinearOrderedField α
inst✝ : DivisionRing β
a✝ a₁ a₂ : α
b : β
q✝ : ℚ
a : α
q : ℚ
h : ↑q ∈ Iio a
⊢ ↑q ∈ cutMap α a
Theorem: Nat.binaryRec_zero
File: Mathlib/Init/Data/Nat/Bitwise.lean

tactic: rw [binaryRec]
state_before: C : ℕ → Sort u
z : C 0
f : (b : Bool) → (n : ℕ) → C n → C (bit b n)
⊢ binaryRec z f 0 = z

tactic: rfl
state_before: C : ℕ → Sort u
z : C 0
f : (b : Bool) → (n : ℕ) → C n → C (bit b n)
⊢ (if n0 : 0 = 0 then Eq.mpr (_ : C 0 = C 0) z
    else
      let n' := div2 0;
      let_fun _x := (_ : bit (bodd 0) (div2 0) = 0);
      Eq.mpr (_ : C 0 = C (bit (bodd 0) n')) (f (bodd 0) n' (binaryRec z f n'))) =
    z
Theorem: MeasureTheory.lintegral_congr
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: simp only [h]
state_before: α : Type u_1
β : Type ?u.294661
γ : Type ?u.294664
δ : Type ?u.294667
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
h : ∀ (a : α), f a = g a
⊢ (∫⁻ (a : α), f a ∂μ) = ∫⁻ (a : α), g a ∂μ
Theorem: CategoryTheory.tensorLeftHomEquiv_tensor_id_comp_evaluation
File: Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean

tactic: dsimp [tensorLeftHomEquiv, leftAdjointMate]
state_before: C : Type u₁
inst✝³ : Category C
inst✝² : MonoidalCategory C
X Y : C
inst✝¹ : HasLeftDual X
inst✝ : HasLeftDual Y
f : X ⟶ Y
⊢ ↑(tensorLeftHomEquiv (ᘁY) (ᘁX) X (𝟙_ C)) ((f ⊗ 𝟙 ᘁY) ≫ ε_ (ᘁY) Y) = (ᘁf) ≫ (ρ_ ᘁX).inv

tactic: simp
state_before: C : Type u₁
inst✝³ : Category C
inst✝² : MonoidalCategory C
X Y : C
inst✝¹ : HasLeftDual X
inst✝ : HasLeftDual Y
f : X ⟶ Y
⊢ (λ_ ᘁY).inv ≫ (η_ (ᘁX) X ⊗ 𝟙 ᘁY) ≫ (α_ (ᘁX) X ᘁY).hom ≫ (𝟙 ᘁX ⊗ (f ⊗ 𝟙 ᘁY) ≫ ε_ (ᘁY) Y) =
    ((λ_ ᘁY).inv ≫ (η_ (ᘁX) X ⊗ 𝟙 ᘁY) ≫ ((𝟙 ᘁX ⊗ f) ⊗ 𝟙 ᘁY) ≫ (α_ (ᘁX) Y ᘁY).hom ≫ (𝟙 ᘁX ⊗ ε_ (ᘁY) Y) ≫ (ρ_ ᘁX).hom) ≫
      (ρ_ ᘁX).inv
Theorem: Subspace.closedComplemented_of_quotient_finiteDimensional
File: Mathlib/Analysis/NormedSpace/Complemented.lean

tactic: obtain ⟨q, hq⟩ : ∃ q, IsCompl p q := p.exists_isCompl
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.131964
G : Type ?u.131967
inst✝⁹ : NontriviallyNormedField 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
inst✝² : CompleteSpace E
p q : Subspace 𝕜 E
inst✝¹ : CompleteSpace 𝕜
inst✝ : FiniteDimensional 𝕜 (E ⧸ p)
hp : IsClosed ↑p
⊢ Submodule.ClosedComplemented p

tactic: haveI : FiniteDimensional 𝕜 q := (p.quotientEquivOfIsCompl q hq).finiteDimensional
state_before: case intro
𝕜 : Type u_1
E : Type u_2
F : Type ?u.131964
G : Type ?u.131967
inst✝⁹ : NontriviallyNormedField 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
inst✝² : CompleteSpace E
p q✝ : Subspace 𝕜 E
inst✝¹ : CompleteSpace 𝕜
inst✝ : FiniteDimensional 𝕜 (E ⧸ p)
hp : IsClosed ↑p
q : Subspace 𝕜 E
hq : IsCompl p q
⊢ Submodule.ClosedComplemented p

tactic: exact closedComplemented_of_closed_compl hq hp q.closed_of_finiteDimensional
state_before: case intro
𝕜 : Type u_1
E : Type u_2
F : Type ?u.131964
G : Type ?u.131967
inst✝⁹ : NontriviallyNormedField 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
inst✝² : CompleteSpace E
p q✝ : Subspace 𝕜 E
inst✝¹ : CompleteSpace 𝕜
inst✝ : FiniteDimensional 𝕜 (E ⧸ p)
hp : IsClosed ↑p
q : Subspace 𝕜 E
hq : IsCompl p q
this : FiniteDimensional 𝕜 { x // x ∈ q }
⊢ Submodule.ClosedComplemented p
Theorem: Ioc_subset_closure_interior
File: Mathlib/Topology/Order/Basic.lean

tactic: rcases eq_or_ne a b with (rfl | h)
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a✝ b✝ : α
s : Set α
a b : α
⊢ Ioc a b ⊆ closure (interior (Ioc a b))

tactic: simp
state_before: case inl
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a✝ b : α
s : Set α
a : α
⊢ Ioc a a ⊆ closure (interior (Ioc a a))

tactic: calc
  Ioc a b ⊆ Icc a b := Ioc_subset_Icc_self
  _ = closure (Ioo a b) := (closure_Ioo h).symm
  _ ⊆ closure (interior (Ioc a b)) :=
    closure_mono (interior_maximal Ioo_subset_Ioc_self isOpen_Ioo)
state_before: case inr
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a✝ b✝ : α
s : Set α
a b : α
h : a ≠ b
⊢ Ioc a b ⊆ closure (interior (Ioc a b))
Theorem: List.tendsto_nhds
File: Mathlib/Topology/List.lean

tactic: rwa [nhds_nil]
state_before: α : Type u_2
β✝ : Type ?u.10411
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β✝
β : Type u_1
f : List α → β
r : List α → Filter β
h_nil : Tendsto f (pure []) (r [])
h_cons : ∀ (l : List α) (a : α), Tendsto f (𝓝 l) (r l) → Tendsto (fun p => f (p.fst :: p.snd)) (𝓝 a ×ˢ 𝓝 l) (r (a :: l))
⊢ Tendsto f (𝓝 []) (r [])

tactic: rw [tendsto_cons_iff]
state_before: α : Type u_2
β✝ : Type ?u.10411
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β✝
β : Type u_1
f : List α → β
r : List α → Filter β
h_nil : Tendsto f (pure []) (r [])
h_cons : ∀ (l : List α) (a : α), Tendsto f (𝓝 l) (r l) → Tendsto (fun p => f (p.fst :: p.snd)) (𝓝 a ×ˢ 𝓝 l) (r (a :: l))
a : α
l : List α
⊢ Tendsto f (𝓝 (a :: l)) (r (a :: l))

tactic: exact h_cons l a (@tendsto_nhds _ _ _ h_nil h_cons l)
state_before: α : Type u_2
β✝ : Type ?u.10411
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β✝
β : Type u_1
f : List α → β
r : List α → Filter β
h_nil : Tendsto f (pure []) (r [])
h_cons : ∀ (l : List α) (a : α), Tendsto f (𝓝 l) (r l) → Tendsto (fun p => f (p.fst :: p.snd)) (𝓝 a ×ˢ 𝓝 l) (r (a :: l))
a : α
l : List α
⊢ Tendsto (fun p => f (p.fst :: p.snd)) (𝓝 a ×ˢ 𝓝 l) (r (a :: l))
Theorem: dist_partial_sum'
File: Mathlib/Analysis/SpecificLimits/Normed.lean

tactic: simp [dist_eq_norm', sum_range_succ]
state_before: α : Type u_1
β : Type ?u.910337
ι : Type ?u.910340
inst✝ : SeminormedAddCommGroup α
r C : ℝ
f u : ℕ → α
n : ℕ
⊢ dist (∑ k in Finset.range n, u k) (∑ k in Finset.range (n + 1), u k) = ‖u n‖
Theorem: CategoryTheory.Limits.limit.isoLimitCone_inv_π
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

tactic: dsimp [limit.isoLimitCone, IsLimit.conePointUniqueUpToIso]
state_before: J : Type u₁
inst✝³ : Category J
K : Type u₂
inst✝² : Category K
C : Type u
inst✝¹ : Category C
F✝ F : J ⥤ C
inst✝ : HasLimit F
t : LimitCone F
j : J
⊢ (isoLimitCone t).inv ≫ π F j = t.cone.π.app j

tactic: aesop_cat
state_before: J : Type u₁
inst✝³ : Category J
K : Type u₂
inst✝² : Category K
C : Type u
inst✝¹ : Category C
F✝ F : J ⥤ C
inst✝ : HasLimit F
t : LimitCone F
j : J
⊢ lift F t.cone ≫ π F j = t.cone.π.app j
Theorem: Nat.size_pos
File: Mathlib/Data/Nat/Size.lean

tactic: rw [lt_size]
state_before: n : ℕ
⊢ 0 < size n ↔ 0 < n

tactic: rfl
state_before: n : ℕ
⊢ 2 ^ 0 ≤ n ↔ 0 < n
Theorem: List.prod_drop_succ
File: Mathlib/Data/List/BigOperators/Basic.lean

tactic: simp [nthLe]
state_before: ι : Type ?u.116361
α : Type ?u.116364
M : Type ?u.116367
N : Type ?u.116370
P : Type ?u.116373
M₀ : Type ?u.116376
G : Type u_1
R : Type ?u.116382
inst✝ : Group G
x : G
xs : List G
x✝ : 0 < length (x :: xs)
⊢ prod (drop (0 + 1) (x :: xs)) = (nthLe (x :: xs) 0 x✝)⁻¹ * prod (drop 0 (x :: xs))
Theorem: AlgebraicTopology.DoldKan.PInfty_add_QInfty
File: Mathlib/AlgebraicTopology/DoldKan/PInfty.lean

tactic: dsimp only [QInfty]
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
⊢ PInfty + QInfty = 𝟙 K[X]

tactic: simp only [add_sub_cancel'_right]
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
⊢ PInfty + (𝟙 K[X] - PInfty) = 𝟙 K[X]
Theorem: QuotientGroup.eq_one_iff
File: Mathlib/GroupTheory/QuotientGroup.lean

tactic: refine' QuotientGroup.eq.trans _
state_before: G : Type u
inst✝¹ : Group G
N✝ : Subgroup G
nN✝ : Subgroup.Normal N✝
H : Type v
inst✝ : Group H
N : Subgroup G
nN : Subgroup.Normal N
x : G
⊢ ↑x = 1 ↔ x ∈ N

tactic: rw [mul_one, Subgroup.inv_mem_iff]
state_before: G : Type u
inst✝¹ : Group G
N✝ : Subgroup G
nN✝ : Subgroup.Normal N✝
H : Type v
inst✝ : Group H
N : Subgroup G
nN : Subgroup.Normal N
x : G
⊢ x⁻¹ * 1 ∈ N ↔ x ∈ N
Theorem: MeasureTheory.ae_smul_measure
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [smul_apply, ae_iff.1 h, smul_zero]
state_before: α : Type u_2
β : Type ?u.579678
γ : Type ?u.579681
δ : Type ?u.579684
ι : Type ?u.579687
R : Type u_1
R' : Type ?u.579693
m0 : MeasurableSpace α
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
p : α → Prop
inst✝² : Monoid R
inst✝¹ : DistribMulAction R ℝ≥0∞
inst✝ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
h : ∀ᵐ (x : α) ∂μ, p x
c : R
⊢ ↑↑(c • μ) {a | ¬p a} = 0
Theorem: QuotientAddGroup.zmultiples_nsmul_eq_nsmul_iff
File: Mathlib/Algebra/CharZero/Quotient.lean

tactic: rw [← coe_nat_zsmul ψ, ← coe_nat_zsmul θ,
  zmultiples_zsmul_eq_zsmul_iff (Int.coe_nat_ne_zero.mpr hz), Int.cast_ofNat]
state_before: R : Type u_1
inst✝¹ : DivisionRing R
inst✝ : CharZero R
p : R
ψ θ : R ⧸ AddSubgroup.zmultiples p
n : ℕ
hz : n ≠ 0
⊢ n • ψ = n • θ ↔ ∃ k, ψ = θ + ↑(↑k • (p / ↑n))

tactic: rfl
state_before: R : Type u_1
inst✝¹ : DivisionRing R
inst✝ : CharZero R
p : R
ψ θ : R ⧸ AddSubgroup.zmultiples p
n : ℕ
hz : n ≠ 0
⊢ (∃ k, ψ = θ + ↑(↑k • (p / ↑n))) ↔ ∃ k, ψ = θ + ↑(↑k • (p / ↑n))
Theorem: Turing.TM2to1.addBottom_nth_snd
File: Mathlib/Computability/TuringMachine.lean

tactic: conv => rhs; rw [← addBottom_map L, ListBlank.nth_map]
state_before: K : Type u_1
inst✝² : DecidableEq K
Γ : K → Type u_2
Λ : Type ?u.602019
inst✝¹ : Inhabited Λ
σ : Type ?u.602025
inst✝ : Inhabited σ
L : ListBlank ((k : K) → Option (Γ k))
n : ℕ
⊢ (ListBlank.nth (addBottom L) n).snd = ListBlank.nth L n
Theorem: Nat.floor_lt_ceil_of_lt_of_pos
File: Mathlib/Algebra/Order/Floor.lean

tactic: rcases le_or_lt 0 a with (ha | ha)
state_before: F : Type ?u.56447
α : Type u_1
β : Type ?u.56453
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n : ℕ
a b : α
h : a < b
h' : 0 < b
⊢ ⌊a⌋₊ < ⌈b⌉₊

tactic: rw [floor_lt ha]
state_before: case inl
F : Type ?u.56447
α : Type u_1
β : Type ?u.56453
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n : ℕ
a b : α
h : a < b
h' : 0 < b
ha : 0 ≤ a
⊢ ⌊a⌋₊ < ⌈b⌉₊

tactic: exact h.trans_le (le_ceil _)
state_before: case inl
F : Type ?u.56447
α : Type u_1
β : Type ?u.56453
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n : ℕ
a b : α
h : a < b
h' : 0 < b
ha : 0 ≤ a
⊢ a < ↑⌈b⌉₊

tactic: rwa [floor_of_nonpos ha.le, lt_ceil, Nat.cast_zero]
state_before: case inr
F : Type ?u.56447
α : Type u_1
β : Type ?u.56453
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n : ℕ
a b : α
h : a < b
h' : 0 < b
ha : a < 0
⊢ ⌊a⌋₊ < ⌈b⌉₊