tasksource/leandojo huggingface dataset:
Theorem: List.forall₂_eq_eq_eq
File: Mathlib/Data/List/Forall2.lean

tactic: funext a b
state_before: α : Type u_1
β : Type ?u.14305
γ : Type ?u.14308
δ : Type ?u.14311
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
⊢ (Forall₂ fun x x_1 => x = x_1) = Eq

tactic: apply propext
state_before: case h.h
α : Type u_1
β : Type ?u.14305
γ : Type ?u.14308
δ : Type ?u.14311
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
a b : List α
⊢ Forall₂ (fun x x_1 => x = x_1) a b = (a = b)

tactic: constructor
state_before: case h.h.a
α : Type u_1
β : Type ?u.14305
γ : Type ?u.14308
δ : Type ?u.14311
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
a b : List α
⊢ Forall₂ (fun x x_1 => x = x_1) a b ↔ a = b

tactic: intro h
state_before: case h.h.a.mp
α : Type u_1
β : Type ?u.14305
γ : Type ?u.14308
δ : Type ?u.14311
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
a b : List α
⊢ Forall₂ (fun x x_1 => x = x_1) a b → a = b

tactic: induction h
state_before: case h.h.a.mp
α : Type u_1
β : Type ?u.14305
γ : Type ?u.14308
δ : Type ?u.14311
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
a b : List α
h : Forall₂ (fun x x_1 => x = x_1) a b
⊢ a = b

tactic: simp only [*]
state_before: case h.h.a.mp.cons
α : Type u_1
β : Type ?u.14305
γ : Type ?u.14308
δ : Type ?u.14311
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
a b : List α
a✝² b✝ : α
l₁✝ l₂✝ : List α
a✝¹ : a✝² = b✝
a✝ : Forall₂ (fun x x_1 => x = x_1) l₁✝ l₂✝
a_ih✝ : l₁✝ = l₂✝
⊢ a✝² :: l₁✝ = b✝ :: l₂✝

tactic: rfl
state_before: case h.h.a.mp.nil
α : Type u_1
β : Type ?u.14305
γ : Type ?u.14308
δ : Type ?u.14311
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
a b : List α
⊢ [] = []

tactic: rintro rfl
state_before: case h.h.a.mpr
α : Type u_1
β : Type ?u.14305
γ : Type ?u.14308
δ : Type ?u.14311
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
a b : List α
⊢ a = b → Forall₂ (fun x x_1 => x = x_1) a b

tactic: exact forall₂_refl _
state_before: case h.h.a.mpr
α : Type u_1
β : Type ?u.14305
γ : Type ?u.14308
δ : Type ?u.14311
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
a : List α
⊢ Forall₂ (fun x x_1 => x = x_1) a a
Theorem: Std.BinomialHeapImp.HeapNode.rankTR_eq
File: Std/Data/BinomialHeap.lean

tactic: simp_arith only [rankTR.go, go, rank]
state_before: α : Type u_1
s : HeapNode α
a✝ : α
child✝ sibling✝ : HeapNode α
x✝ : Nat
⊢ rankTR.go (node a✝ child✝ sibling✝) x✝ = rank (node a✝ child✝ sibling✝) + x✝
Theorem: CategoryTheory.MonoidalCategory.rightUnitor_tensor_inv
File: Mathlib/CategoryTheory/Monoidal/Category.lean

tactic: simp
state_before: C✝ : Type u
𝒞 : Category C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category C
inst✝ : MonoidalCategory C
U V W X✝ Y✝ Z X Y : C
⊢ inv (ρ_ (X ⊗ Y)).inv = inv ((𝟙 X ⊗ (ρ_ Y).inv) ≫ (α_ X Y (𝟙_ C)).inv)
Theorem: Ideal.top_pow
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: rw [pow_succ, ih, top_mul]
state_before: R : Type u
ι : Type ?u.338111
inst✝ : CommSemiring R
I J K L : Ideal R
n✝ n : ℕ
ih : ⊤ ^ n = ⊤
⊢ ⊤ ^ Nat.succ n = ⊤
Theorem: ENNReal.rpow_add_rpow_le_add
File: Mathlib/Analysis/MeanInequalitiesPow.lean

tactic: rw [← @ENNReal.le_rpow_one_div_iff _ _ (1 / p) (by simp [lt_of_lt_of_le zero_lt_one hp1])]
state_before: ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0∞
hp1 : 1 ≤ p
⊢ (a ^ p + b ^ p) ^ (1 / p) ≤ a + b

tactic: rw [one_div_one_div]
state_before: ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0∞
hp1 : 1 ≤ p
⊢ a ^ p + b ^ p ≤ (a + b) ^ (1 / (1 / p))

tactic: exact add_rpow_le_rpow_add _ _ hp1
state_before: ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0∞
hp1 : 1 ≤ p
⊢ a ^ p + b ^ p ≤ (a + b) ^ p

tactic: simp [lt_of_lt_of_le zero_lt_one hp1]
state_before: ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0∞
hp1 : 1 ≤ p
⊢ 0 < 1 / p
Theorem: Finsupp.prod_single_index
File: Mathlib/Algebra/BigOperators/Finsupp.lean

tactic: simp
state_before: α : Type u_3
ι : Type ?u.27350
γ : Type ?u.27353
A : Type ?u.27356
B : Type ?u.27359
C : Type ?u.27362
inst✝⁵ : AddCommMonoid A
inst✝⁴ : AddCommMonoid B
inst✝³ : AddCommMonoid C
t : ι → A → C
h0 : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s : Finset α
f : α → ι →₀ A
i : ι
g : ι →₀ A
k : ι → A → γ → B
x : γ
β : Type ?u.30492
M : Type u_2
M' : Type ?u.30498
N : Type u_1
P : Type ?u.30504
G : Type ?u.30507
H : Type ?u.30510
R : Type ?u.30513
S : Type ?u.30516
inst✝² : Zero M
inst✝¹ : Zero M'
inst✝ : CommMonoid N
a : α
b : M
h : α → M → N
h_zero : h a 0 = 1
⊢ ∏ x in {a}, h x (↑(single a b) x) = h a b
Theorem: List.get?_eq_none
File: Std/Data/List/Lemmas.lean

tactic: cases e ▸ get?_eq_some.2 ⟨h', rfl⟩
state_before: α✝ : Type u_1
l : List α✝
n : Nat
e : get? l n = none
h' : n < length l
⊢ False
Theorem: openSegment_eq_Ioo'
File: Mathlib/Analysis/Convex/Segment.lean

tactic: cases' hxy.lt_or_lt with h h
state_before: 𝕜 : Type u_1
E : Type ?u.290354
F : Type ?u.290357
G : Type ?u.290360
ι : Type ?u.290363
π : ι → Type ?u.290368
inst✝ : LinearOrderedField 𝕜
x y z : 𝕜
hxy : x ≠ y
⊢ openSegment 𝕜 x y = Ioo (min x y) (max x y)

tactic: rw [openSegment_eq_Ioo h, max_eq_right h.le, min_eq_left h.le]
state_before: case inl
𝕜 : Type u_1
E : Type ?u.290354
F : Type ?u.290357
G : Type ?u.290360
ι : Type ?u.290363
π : ι → Type ?u.290368
inst✝ : LinearOrderedField 𝕜
x y z : 𝕜
hxy : x ≠ y
h : x < y
⊢ openSegment 𝕜 x y = Ioo (min x y) (max x y)

tactic: rw [openSegment_symm, openSegment_eq_Ioo h, max_eq_left h.le, min_eq_right h.le]
state_before: case inr
𝕜 : Type u_1
E : Type ?u.290354
F : Type ?u.290357
G : Type ?u.290360
ι : Type ?u.290363
π : ι → Type ?u.290368
inst✝ : LinearOrderedField 𝕜
x y z : 𝕜
hxy : x ≠ y
h : y < x
⊢ openSegment 𝕜 x y = Ioo (min x y) (max x y)
Theorem: RatFunc.laurentAux_div
File: Mathlib/FieldTheory/Laurent.lean

tactic: exact taylor_mem_nonZeroDivisors r
state_before: R : Type u
inst✝ : CommRing R
hdomain : IsDomain R
r s : R
p q : R[X]
f : RatFunc R
⊢ R[X]⁰ ≤
    Submonoid.comap
      {
        toMonoidHom :=
          { toOneHom := { toFun := ↑(taylor r), map_one' := (_ : ↑(taylor r) 1 = ↑Polynomial.C 1) },
            map_mul' := (_ : ∀ (p q : R[X]), ↑(taylor r) (p * q) = ↑(taylor r) p * ↑(taylor r) q) },
        map_zero' := (_ : ↑(taylor r) 0 = 0),
        map_add' := (_ : ∀ (x y : R[X]), ↑(taylor r) (x + y) = ↑(taylor r) x + ↑(taylor r) y) }
      R[X]⁰
Theorem: AffineSubspace.directionOfNonempty_eq_direction
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: refine le_antisymm ?_ (Submodule.span_le.2 Set.Subset.rfl)
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
h : Set.Nonempty ↑s
⊢ directionOfNonempty h = direction s

tactic: rw [← SetLike.coe_subset_coe, directionOfNonempty, direction, Submodule.coe_set_mk,
  AddSubmonoid.coe_set_mk]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
h : Set.Nonempty ↑s
⊢ directionOfNonempty h ≤ direction s

tactic: exact (vsub_set_subset_vectorSpan k _)
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
h : Set.Nonempty ↑s
⊢ ↑s -ᵥ ↑s ⊆ ↑(vectorSpan k ↑s)
Theorem: matrixEquivTensor_apply_symm
File: Mathlib/RingTheory/MatrixAlgebra.lean

tactic: simp [matrixEquivTensor, MatrixEquivTensor.toFunAlgHom, algHomOfLinearMapTensorProduct,
  MatrixEquivTensor.toFunLinear]
state_before: R : Type u
inst✝⁴ : CommSemiring R
A : Type v
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : Fintype n
inst✝ : DecidableEq n
a : A
M : Matrix n n R
⊢ ↑(AlgEquiv.symm (matrixEquivTensor R A n)) (a ⊗ₜ[R] M) = Matrix.map M fun x => a * ↑(algebraMap R A) x

tactic: rfl
state_before: R : Type u
inst✝⁴ : CommSemiring R
A : Type v
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : Fintype n
inst✝ : DecidableEq n
a : A
M : Matrix n n R
⊢ AddHom.toFun (lift (toFunBilinear R A n)).toAddHom (a ⊗ₜ[R] M) = Matrix.map M fun x => a * ↑(algebraMap R A) x
Theorem: Function.LeftInverse.iterate
File: Mathlib/Logic/Function/Iterate.lean

tactic: rw [iterate_succ', iterate_succ]
state_before: α : Type u
β : Type v
f : α → α
m n✝¹ : ℕ
a : α
g : α → α
hg : LeftInverse g f
n✝ n : ℕ
ihn : LeftInverse (g^[n]) (f^[n])
⊢ LeftInverse (g^[Nat.succ n]) (f^[Nat.succ n])

tactic: exact ihn.comp hg
state_before: α : Type u
β : Type v
f : α → α
m n✝¹ : ℕ
a : α
g : α → α
hg : LeftInverse g f
n✝ n : ℕ
ihn : LeftInverse (g^[n]) (f^[n])
⊢ LeftInverse (g ∘ g^[n]) (f^[n] ∘ f)
Theorem: PrincipalSeg.topLTTop
File: Mathlib/Order/InitialSeg.lean

tactic: rw [Subsingleton.elim h (f.trans g)]
state_before: α : Type u_2
β : Type u_3
γ : Type u_1
r✝ : α → α → Prop
s✝ : β → β → Prop
t✝ : γ → γ → Prop
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
inst✝ : IsWellOrder γ t
f : r ≺i s
g : s ≺i t
h : r ≺i t
⊢ t h.top g.top

tactic: apply PrincipalSeg.lt_top
state_before: α : Type u_2
β : Type u_3
γ : Type u_1
r✝ : α → α → Prop
s✝ : β → β → Prop
t✝ : γ → γ → Prop
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
inst✝ : IsWellOrder γ t
f : r ≺i s
g : s ≺i t
h : r ≺i t
⊢ t (PrincipalSeg.trans f g).top g.top
Theorem: Ordinal.nat_cast_sub
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: cases' le_total m n with h h
state_before: m n : ℕ
⊢ ↑(m - n) = ↑m - ↑n

tactic: rw [tsub_eq_zero_iff_le.2 h, Ordinal.sub_eq_zero_iff_le.2 (nat_cast_le.2 h)]
state_before: case inl
m n : ℕ
h : m ≤ n
⊢ ↑(m - n) = ↑m - ↑n

tactic: rfl
state_before: case inl
m n : ℕ
h : m ≤ n
⊢ ↑0 = 0

tactic: apply (add_left_cancel n).1
state_before: case inr
m n : ℕ
h : n ≤ m
⊢ ↑(m - n) = ↑m - ↑n

tactic: rw [← Nat.cast_add, add_tsub_cancel_of_le h, Ordinal.add_sub_cancel_of_le (nat_cast_le.2 h)]
state_before: case inr
m n : ℕ
h : n ≤ m
⊢ ↑n + ↑(m - n) = ↑n + (↑m - ↑n)
Theorem: MulChar.IsQuadratic.pow_char
File: Mathlib/NumberTheory/LegendreSymbol/MulCharacter.lean

tactic: ext x
state_before: R : Type u
inst✝³ : CommRing R
R' : Type v
inst✝² : CommRing R'
R'' : Type w
inst✝¹ : CommRing R''
χ : MulChar R R'
hχ : IsQuadratic χ
p : ℕ
hp : Fact (Nat.Prime p)
inst✝ : CharP R' p
⊢ χ ^ p = χ

tactic: rw [pow_apply_coe]
state_before: case h
R : Type u
inst✝³ : CommRing R
R' : Type v
inst✝² : CommRing R'
R'' : Type w
inst✝¹ : CommRing R''
χ : MulChar R R'
hχ : IsQuadratic χ
p : ℕ
hp : Fact (Nat.Prime p)
inst✝ : CharP R' p
x : Rˣ
⊢ ↑(χ ^ p) ↑x = ↑χ ↑x

tactic: rcases hχ x with (hx | hx | hx) <;> rw [hx]
state_before: case h
R : Type u
inst✝³ : CommRing R
R' : Type v
inst✝² : CommRing R'
R'' : Type w
inst✝¹ : CommRing R''
χ : MulChar R R'
hχ : IsQuadratic χ
p : ℕ
hp : Fact (Nat.Prime p)
inst✝ : CharP R' p
x : Rˣ
⊢ ↑χ ↑x ^ p = ↑χ ↑x

tactic: rw [zero_pow (@Fact.out p.Prime).pos]
state_before: case h.inl
R : Type u
inst✝³ : CommRing R
R' : Type v
inst✝² : CommRing R'
R'' : Type w
inst✝¹ : CommRing R''
χ : MulChar R R'
hχ : IsQuadratic χ
p : ℕ
hp : Fact (Nat.Prime p)
inst✝ : CharP R' p
x : Rˣ
hx : ↑χ ↑x = 0
⊢ 0 ^ p = 0

tactic: rw [one_pow]
state_before: case h.inr.inl
R : Type u
inst✝³ : CommRing R
R' : Type v
inst✝² : CommRing R'
R'' : Type w
inst✝¹ : CommRing R''
χ : MulChar R R'
hχ : IsQuadratic χ
p : ℕ
hp : Fact (Nat.Prime p)
inst✝ : CharP R' p
x : Rˣ
hx : ↑χ ↑x = 1
⊢ 1 ^ p = 1

tactic: exact CharP.neg_one_pow_char R' p
state_before: case h.inr.inr
R : Type u
inst✝³ : CommRing R
R' : Type v
inst✝² : CommRing R'
R'' : Type w
inst✝¹ : CommRing R''
χ : MulChar R R'
hχ : IsQuadratic χ
p : ℕ
hp : Fact (Nat.Prime p)
inst✝ : CharP R' p
x : Rˣ
hx : ↑χ ↑x = -1
⊢ (-1) ^ p = -1
Theorem: Finset.sum_smul_sum
File: Mathlib/Algebra/Module/BigOperators.lean

tactic: rw [Finset.sum_product, Finset.sum_smul, Finset.sum_congr rfl]
state_before: α : Type u_1
β : Type u_2
R : Type u_4
M : Type u_3
ι : Type ?u.35638
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
r s✝ : R
x y : M
f : α → R
g : β → M
s : Finset α
t : Finset β
⊢ (∑ i in s, f i) • ∑ i in t, g i = ∑ p in s ×ˢ t, f p.fst • g p.snd

tactic: intros
state_before: α : Type u_1
β : Type u_2
R : Type u_4
M : Type u_3
ι : Type ?u.35638
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
r s✝ : R
x y : M
f : α → R
g : β → M
s : Finset α
t : Finset β
⊢ ∀ (x : α), x ∈ s → f x • ∑ i in t, g i = ∑ y in t, f (x, y).fst • g (x, y).snd

tactic: rw [Finset.smul_sum]
state_before: α : Type u_1
β : Type u_2
R : Type u_4
M : Type u_3
ι : Type ?u.35638
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
r s✝ : R
x y : M
f : α → R
g : β → M
s : Finset α
t : Finset β
x✝ : α
a✝ : x✝ ∈ s
⊢ f x✝ • ∑ i in t, g i = ∑ y in t, f (x✝, y).fst • g (x✝, y).snd
Theorem: Function.Bijective.comp_right
File: Mathlib/Logic/Function/Basic.lean

tactic: simp only [comp.assoc g _ f, (leftInverse_surjInv hf).comp_eq_id, comp.right_id]
state_before: α : Sort u_1
β : Sort u_2
γ : Sort u_3
f : α → β
hf : Bijective f
g : α → γ
⊢ (fun g => g ∘ f) (g ∘ surjInv (_ : Surjective f)) = g
Theorem: CompleteLattice.setIndependent_pair
File: Mathlib/Order/SupIndep.lean

tactic: constructor
state_before: α : Type u_1
β : Type ?u.24528
ι : Type ?u.24531
ι' : Type ?u.24534
inst✝ : CompleteLattice α
s : Set α
hs : SetIndependent s
a b : α
hab : a ≠ b
⊢ SetIndependent {a, b} ↔ Disjoint a b

tactic: intro h
state_before: case mp
α : Type u_1
β : Type ?u.24528
ι : Type ?u.24531
ι' : Type ?u.24534
inst✝ : CompleteLattice α
s : Set α
hs : SetIndependent s
a b : α
hab : a ≠ b
⊢ SetIndependent {a, b} → Disjoint a b

tactic: exact h.pairwiseDisjoint (mem_insert _ _) (mem_insert_of_mem _ (mem_singleton _)) hab
state_before: case mp
α : Type u_1
β : Type ?u.24528
ι : Type ?u.24531
ι' : Type ?u.24534
inst✝ : CompleteLattice α
s : Set α
hs : SetIndependent s
a b : α
hab : a ≠ b
h : SetIndependent {a, b}
⊢ Disjoint a b

tactic: rintro h c ((rfl : c = a) | (rfl : c = b))
state_before: case mpr
α : Type u_1
β : Type ?u.24528
ι : Type ?u.24531
ι' : Type ?u.24534
inst✝ : CompleteLattice α
s : Set α
hs : SetIndependent s
a b : α
hab : a ≠ b
⊢ Disjoint a b → SetIndependent {a, b}

tactic: convert h using 1
state_before: case mpr.inl
α : Type u_1
β : Type ?u.24528
ι : Type ?u.24531
ι' : Type ?u.24534
inst✝ : CompleteLattice α
s : Set α
hs : SetIndependent s
b c : α
hab : c ≠ b
h : Disjoint c b
⊢ Disjoint c (sSup ({c, b} \ {c}))

tactic: simp [hab, sSup_singleton]
state_before: case h.e'_5
α : Type u_1
β : Type ?u.24528
ι : Type ?u.24531
ι' : Type ?u.24534
inst✝ : CompleteLattice α
s : Set α
hs : SetIndependent s
b c : α
hab : c ≠ b
h : Disjoint c b
⊢ sSup ({c, b} \ {c}) = b

tactic: convert h.symm using 1
state_before: case mpr.inr
α : Type u_1
β : Type ?u.24528
ι : Type ?u.24531
ι' : Type ?u.24534
inst✝ : CompleteLattice α
s : Set α
hs : SetIndependent s
a c : α
hab : a ≠ c
h : Disjoint a c
⊢ Disjoint c (sSup ({a, c} \ {c}))

tactic: simp [hab, sSup_singleton]
state_before: case h.e'_5
α : Type u_1
β : Type ?u.24528
ι : Type ?u.24531
ι' : Type ?u.24534
inst✝ : CompleteLattice α
s : Set α
hs : SetIndependent s
a c : α
hab : a ≠ c
h : Disjoint a c
⊢ sSup ({a, c} \ {c}) = a
Theorem: List.map_eq_append_split
File: Std/Data/List/Lemmas.lean

tactic: have := h
state_before: α : Type u_1
β : Type u_2
f : α → β
l : List α
s₁ s₂ : List β
h : map f l = s₁ ++ s₂
⊢ ∃ l₁ l₂, l = l₁ ++ l₂ ∧ map f l₁ = s₁ ∧ map f l₂ = s₂

tactic: rw [← take_append_drop (length s₁) l] at this ⊢
state_before: α : Type u_1
β : Type u_2
f : α → β
l : List α
s₁ s₂ : List β
h this : map f l = s₁ ++ s₂
⊢ ∃ l₁ l₂, l = l₁ ++ l₂ ∧ map f l₁ = s₁ ∧ map f l₂ = s₂

tactic: rw [map_append] at this
state_before: α : Type u_1
β : Type u_2
f : α → β
l : List α
s₁ s₂ : List β
h : map f l = s₁ ++ s₂
this : map f (take (length s₁) l ++ drop (length s₁) l) = s₁ ++ s₂
⊢ ∃ l₁ l₂, take (length s₁) l ++ drop (length s₁) l = l₁ ++ l₂ ∧ map f l₁ = s₁ ∧ map f l₂ = s₂

tactic: refine ⟨_, _, rfl, append_inj this ?_⟩
state_before: α : Type u_1
β : Type u_2
f : α → β
l : List α
s₁ s₂ : List β
h : map f l = s₁ ++ s₂
this : map f (take (length s₁) l) ++ map f (drop (length s₁) l) = s₁ ++ s₂
⊢ ∃ l₁ l₂, take (length s₁) l ++ drop (length s₁) l = l₁ ++ l₂ ∧ map f l₁ = s₁ ∧ map f l₂ = s₂

tactic: rw [length_map, length_take, Nat.min_eq_left]
state_before: α : Type u_1
β : Type u_2
f : α → β
l : List α
s₁ s₂ : List β
h : map f l = s₁ ++ s₂
this : map f (take (length s₁) l) ++ map f (drop (length s₁) l) = s₁ ++ s₂
⊢ length (map f (take (length s₁) l)) = length s₁

tactic: rw [← length_map l f, h, length_append]
state_before: α : Type u_1
β : Type u_2
f : α → β
l : List α
s₁ s₂ : List β
h : map f l = s₁ ++ s₂
this : map f (take (length s₁) l) ++ map f (drop (length s₁) l) = s₁ ++ s₂
⊢ length s₁ ≤ length l

tactic: apply Nat.le_add_right
state_before: α : Type u_1
β : Type u_2
f : α → β
l : List α
s₁ s₂ : List β
h : map f l = s₁ ++ s₂
this : map f (take (length s₁) l) ++ map f (drop (length s₁) l) = s₁ ++ s₂
⊢ length s₁ ≤ length s₁ + length s₂
Theorem: inv_lt_one_iff
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: cases' le_or_lt a 0 with ha ha
state_before: ι : Type ?u.55403
α : Type u_1
β : Type ?u.55409
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
⊢ a⁻¹ < 1 ↔ a ≤ 0 ∨ 1 < a

tactic: simp [ha, (inv_nonpos.2 ha).trans_lt zero_lt_one]
state_before: case inl
ι : Type ?u.55403
α : Type u_1
β : Type ?u.55409
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
ha : a ≤ 0
⊢ a⁻¹ < 1 ↔ a ≤ 0 ∨ 1 < a

tactic: simp only [ha.not_le, false_or_iff, inv_lt_one_iff_of_pos ha]
state_before: case inr
ι : Type ?u.55403
α : Type u_1
β : Type ?u.55409
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
ha : 0 < a
⊢ a⁻¹ < 1 ↔ a ≤ 0 ∨ 1 < a
Theorem: RatFunc.mk_eq_div'
File: Mathlib/FieldTheory/RatFunc.lean

tactic: rw [RatFunc.mk]
state_before: K : Type u
inst✝¹ : CommRing K
inst✝ : IsDomain K
p q : K[X]
⊢ RatFunc.mk p q =
    { toFractionRing := ↑(algebraMap K[X] (FractionRing K[X])) p / ↑(algebraMap K[X] (FractionRing K[X])) q }
Theorem: Cardinal.aleph0_le_lift
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [← lift_aleph0.{u,v}, lift_le]
state_before: α β : Type u
c : Cardinal
⊢ ℵ₀ ≤ lift c ↔ ℵ₀ ≤ c
Theorem: MeasureTheory.weightedSMul_union'
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: ext1 x
state_before: α : Type u_1
E : Type ?u.49399
F : Type u_2
𝕜 : Type ?u.49405
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m : MeasurableSpace α
μ : Measure α
s t : Set α
ht : MeasurableSet t
hs_finite : ↑↑μ s ≠ ⊤
ht_finite : ↑↑μ t ≠ ⊤
h_inter : s ∩ t = ∅
⊢ weightedSMul μ (s ∪ t) = weightedSMul μ s + weightedSMul μ t

tactic: simp_rw [add_apply, weightedSMul_apply,
  measure_union (Set.disjoint_iff_inter_eq_empty.mpr h_inter) ht,
  ENNReal.toReal_add hs_finite ht_finite, add_smul]
state_before: case h
α : Type u_1
E : Type ?u.49399
F : Type u_2
𝕜 : Type ?u.49405
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m : MeasurableSpace α
μ : Measure α
s t : Set α
ht : MeasurableSet t
hs_finite : ↑↑μ s ≠ ⊤
ht_finite : ↑↑μ t ≠ ⊤
h_inter : s ∩ t = ∅
x : F
⊢ ↑(weightedSMul μ (s ∪ t)) x = ↑(weightedSMul μ s + weightedSMul μ t) x
Theorem: Equiv.Perm.lcm_cycleType
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

tactic: induction σ using cycle_induction_on with
| base_one => simp
| base_cycles σ hσ => simp [hσ.cycleType, hσ.orderOf]
| induction_disjoint σ τ hd _ hσ hτ => simp [hd.cycleType, hd.orderOf, lcm_eq_nat_lcm, hσ, hτ]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ : Perm α
⊢ Multiset.lcm (cycleType σ) = orderOf σ

tactic: simp
state_before: case base_one
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
⊢ Multiset.lcm (cycleType 1) = orderOf 1

tactic: simp [hσ.cycleType, hσ.orderOf]
state_before: case base_cycles
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ : Perm α
hσ : IsCycle σ
⊢ Multiset.lcm (cycleType σ) = orderOf σ

tactic: simp [hd.cycleType, hd.orderOf, lcm_eq_nat_lcm, hσ, hτ]
state_before: case induction_disjoint
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ τ : Perm α
hd : Disjoint σ τ
a✝ : IsCycle σ
hσ : Multiset.lcm (cycleType σ) = orderOf σ
hτ : Multiset.lcm (cycleType τ) = orderOf τ
⊢ Multiset.lcm (cycleType (σ * τ)) = orderOf (σ * τ)
Theorem: Filter.atTop_Ioi_eq
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: rcases isEmpty_or_nonempty (Ioi a) with h|⟨⟨b, hb⟩⟩
state_before: ι : Type ?u.326160
ι' : Type ?u.326163
α : Type u_1
β : Type ?u.326169
γ : Type ?u.326172
inst✝ : SemilatticeSup α
a : α
⊢ atTop = comap Subtype.val atTop

tactic: exact Subsingleton.elim _ _
state_before: case inl
ι : Type ?u.326160
ι' : Type ?u.326163
α : Type u_1
β : Type ?u.326169
γ : Type ?u.326172
inst✝ : SemilatticeSup α
a : α
h : IsEmpty ↑(Ioi a)
⊢ atTop = comap Subtype.val atTop

tactic: rw [← map_val_atTop_of_Ici_subset (Ici_subset_Ioi.2 hb), comap_map Subtype.coe_injective]
state_before: case inr.intro.mk
ι : Type ?u.326160
ι' : Type ?u.326163
α : Type u_1
β : Type ?u.326169
γ : Type ?u.326172
inst✝ : SemilatticeSup α
a b : α
hb : b ∈ Ioi a
⊢ atTop = comap Subtype.val atTop
Theorem: dense_irrational
File: Mathlib/Topology/Instances/Irrational.lean

tactic: refine' Real.isTopologicalBasis_Ioo_rat.dense_iff.2 _
state_before: ⊢ Dense {x | Irrational x}

tactic: simp only [gt_iff_lt, Rat.cast_lt, not_lt, ge_iff_le, Rat.cast_le, mem_iUnion, mem_singleton_iff,
  exists_prop, forall_exists_index, and_imp]
state_before: ⊢ ∀ (o : Set ℝ),
    (o ∈ ⋃ (a : ℚ) (b : ℚ) (_ : a < b), {Ioo ↑a ↑b}) → Set.Nonempty o → Set.Nonempty (o ∩ {x | Irrational x})

tactic: rintro _ a b hlt rfl _
state_before: ⊢ ∀ (o : Set ℝ) (x x_1 : ℚ), x < x_1 → o = Ioo ↑x ↑x_1 → Set.Nonempty o → Set.Nonempty (o ∩ {x | Irrational x})

tactic: rw [inter_comm]
state_before: a b : ℚ
hlt : a < b
a✝ : Set.Nonempty (Ioo ↑a ↑b)
⊢ Set.Nonempty (Ioo ↑a ↑b ∩ {x | Irrational x})

tactic: exact exists_irrational_btwn (Rat.cast_lt.2 hlt)
state_before: a b : ℚ
hlt : a < b
a✝ : Set.Nonempty (Ioo ↑a ↑b)
⊢ Set.Nonempty ({x | Irrational x} ∩ Ioo ↑a ↑b)
Theorem: SeminormFamily.withSeminorms_iff_uniformSpace_eq_iInf
File: Mathlib/Analysis/LocallyConvex/WithSeminorms.lean

tactic: rw [p.withSeminorms_iff_nhds_eq_iInf,
  UniformAddGroup.ext_iff inferInstance (uniformAddGroup_iInf fun i => inferInstance),
  toTopologicalSpace_iInf, nhds_iInf]
state_before: 𝕜 : Type u_2
𝕜₂ : Type ?u.451403
𝕝 : Type ?u.451406
𝕝₂ : Type ?u.451409
E : Type u_1
F : Type ?u.451415
G : Type ?u.451418
ι : Type u_3
ι' : Type ?u.451424
inst✝⁴ : NormedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : Nonempty ι
u : UniformSpace E
inst✝ : UniformAddGroup E
p : SeminormFamily 𝕜 E ι
⊢ WithSeminorms p ↔ u = ⨅ (i : ι), PseudoMetricSpace.toUniformSpace

tactic: refine Eq.to_iff ?_
state_before: 𝕜 : Type u_2
𝕜₂ : Type ?u.451403
𝕝 : Type ?u.451406
𝕝₂ : Type ?u.451409
E : Type u_1
F : Type ?u.451415
G : Type ?u.451418
ι : Type u_3
ι' : Type ?u.451424
inst✝⁴ : NormedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : Nonempty ι
u : UniformSpace E
inst✝ : UniformAddGroup E
p : SeminormFamily 𝕜 E ι
⊢ (𝓝 0 = ⨅ (i : ι), Filter.comap (↑(p i)) (𝓝 0)) ↔ 𝓝 0 = ⨅ (i : ι), 𝓝 0

tactic: congr
state_before: 𝕜 : Type u_2
𝕜₂ : Type ?u.451403
𝕝 : Type ?u.451406
𝕝₂ : Type ?u.451409
E : Type u_1
F : Type ?u.451415
G : Type ?u.451418
ι : Type u_3
ι' : Type ?u.451424
inst✝⁴ : NormedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : Nonempty ι
u : UniformSpace E
inst✝ : UniformAddGroup E
p : SeminormFamily 𝕜 E ι
⊢ (𝓝 0 = ⨅ (i : ι), Filter.comap (↑(p i)) (𝓝 0)) = (𝓝 0 = ⨅ (i : ι), 𝓝 0)

tactic: funext i
state_before: case e_a.e_s
𝕜 : Type u_2
𝕜₂ : Type ?u.451403
𝕝 : Type ?u.451406
𝕝₂ : Type ?u.451409
E : Type u_1
F : Type ?u.451415
G : Type ?u.451418
ι : Type u_3
ι' : Type ?u.451424
inst✝⁴ : NormedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : Nonempty ι
u : UniformSpace E
inst✝ : UniformAddGroup E
p : SeminormFamily 𝕜 E ι
⊢ (fun i => Filter.comap (↑(p i)) (𝓝 0)) = fun i => 𝓝 0

tactic: exact @comap_norm_nhds_zero _ (p i).toAddGroupSeminorm.toSeminormedAddGroup
state_before: case e_a.e_s.h
𝕜 : Type u_2
𝕜₂ : Type ?u.451403
𝕝 : Type ?u.451406
𝕝₂ : Type ?u.451409
E : Type u_1
F : Type ?u.451415
G : Type ?u.451418
ι : Type u_3
ι' : Type ?u.451424
inst✝⁴ : NormedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : Nonempty ι
u : UniformSpace E
inst✝ : UniformAddGroup E
p : SeminormFamily 𝕜 E ι
i : ι
⊢ Filter.comap (↑(p i)) (𝓝 0) = 𝓝 0