tasksource/leandojo huggingface dataset:
Theorem: Ideal.ramificationIdx_lt
File: Mathlib/NumberTheory/RamificationInertia.lean

tactic: cases' n with n n
state_before: R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
n : ℕ
hgt : ¬map f p ≤ P ^ n
⊢ ramificationIdx f p P < n

tactic: simp at hgt
state_before: case zero
R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
hgt : ¬map f p ≤ P ^ Nat.zero
⊢ ramificationIdx f p P < Nat.zero

tactic: rw [Nat.lt_succ_iff]
state_before: case succ
R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
n : ℕ
hgt : ¬map f p ≤ P ^ Nat.succ n
⊢ ramificationIdx f p P < Nat.succ n

tactic: have : ∀ k, map f p ≤ P ^ k → k ≤ n := by
  refine fun k hk => le_of_not_lt fun hnk => ?_
  exact hgt (hk.trans (Ideal.pow_le_pow hnk))
state_before: case succ
R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
n : ℕ
hgt : ¬map f p ≤ P ^ Nat.succ n
⊢ ramificationIdx f p P ≤ n

tactic: rw [ramificationIdx_eq_find ⟨n, this⟩]
state_before: case succ
R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
n : ℕ
hgt : ¬map f p ≤ P ^ Nat.succ n
this : ∀ (k : ℕ), map f p ≤ P ^ k → k ≤ n
⊢ ramificationIdx f p P ≤ n

tactic: exact Nat.find_min' ⟨n, this⟩ this
state_before: case succ
R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
n : ℕ
hgt : ¬map f p ≤ P ^ Nat.succ n
this : ∀ (k : ℕ), map f p ≤ P ^ k → k ≤ n
⊢ Nat.find (_ : ∃ n, ∀ (k : ℕ), map f p ≤ P ^ k → k ≤ n) ≤ n

tactic: refine fun k hk => le_of_not_lt fun hnk => ?_
state_before: R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
n : ℕ
hgt : ¬map f p ≤ P ^ Nat.succ n
⊢ ∀ (k : ℕ), map f p ≤ P ^ k → k ≤ n

tactic: exact hgt (hk.trans (Ideal.pow_le_pow hnk))
state_before: R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
n : ℕ
hgt : ¬map f p ≤ P ^ Nat.succ n
k : ℕ
hk : map f p ≤ P ^ k
hnk : n < k
⊢ False
Theorem: List.get_zipWith
File: Mathlib/Data/List/Zip.lean

tactic: rw [← Option.some_inj, ← get?_eq_get, get?_zip_with_eq_some]
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type ?u.159788
ε : Type ?u.159791
f : α → β → γ
l : List α
l' : List β
i : Fin (length (zipWith f l l'))
⊢ get (zipWith f l l') i =
    f (get l { val := ↑i, isLt := (_ : ↑i < length l) }) (get l' { val := ↑i, isLt := (_ : ↑i < length l') })

tactic: exact
  ⟨l.get ⟨i, lt_length_left_of_zipWith i.isLt⟩, l'.get ⟨i, lt_length_right_of_zipWith i.isLt⟩,
    by rw [get?_eq_get], by rw [get?_eq_get]; exact ⟨rfl, rfl⟩⟩
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type ?u.159788
ε : Type ?u.159791
f : α → β → γ
l : List α
l' : List β
i : Fin (length (zipWith f l l'))
⊢ ∃ x y,
    get? l ↑i = some x ∧
      get? l' ↑i = some y ∧
        f x y =
          f (get l { val := ↑i, isLt := (_ : ↑i < length l) }) (get l' { val := ↑i, isLt := (_ : ↑i < length l') })

tactic: rw [get?_eq_get]
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type ?u.159788
ε : Type ?u.159791
f : α → β → γ
l : List α
l' : List β
i : Fin (length (zipWith f l l'))
⊢ get? l ↑i = some (get l { val := ↑i, isLt := (_ : ↑i < length l) })

tactic: rw [get?_eq_get]
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type ?u.159788
ε : Type ?u.159791
f : α → β → γ
l : List α
l' : List β
i : Fin (length (zipWith f l l'))
⊢ get? l' ↑i = some (get l' { val := ↑i, isLt := (_ : ↑i < length l') }) ∧
    f (get l { val := ↑i, isLt := (_ : ↑i < length l) }) (get l' { val := ↑i, isLt := (_ : ↑i < length l') }) =
      f (get l { val := ↑i, isLt := (_ : ↑i < length l) }) (get l' { val := ↑i, isLt := (_ : ↑i < length l') })

tactic: exact ⟨rfl, rfl⟩
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type ?u.159788
ε : Type ?u.159791
f : α → β → γ
l : List α
l' : List β
i : Fin (length (zipWith f l l'))
⊢ some (get l' { val := ↑i, isLt := ?m.160309 }) = some (get l' { val := ↑i, isLt := (_ : ↑i < length l') }) ∧
    f (get l { val := ↑i, isLt := (_ : ↑i < length l) }) (get l' { val := ↑i, isLt := (_ : ↑i < length l') }) =
      f (get l { val := ↑i, isLt := (_ : ↑i < length l) }) (get l' { val := ↑i, isLt := (_ : ↑i < length l') })

α : Type u
β : Type u_1
γ : Type u_2
δ : Type ?u.159788
ε : Type ?u.159791
f : α → β → γ
l : List α
l' : List β
i : Fin (length (zipWith f l l'))
⊢ ↑i < length l'
Theorem: Nat.Primrec'.add
File: Mathlib/Computability/Primrec.lean

tactic: simp
state_before: v : Vector ℕ (Nat.succ 0 + 1)
⊢ Nat.rec (Vector.head (Vector.tail v)) (fun y IH => Nat.succ (Vector.head (Vector.tail (y ::ᵥ IH ::ᵥ Vector.tail v))))
      (Vector.head v) =
    Vector.head v + Vector.head (Vector.tail v)

tactic: induction v.head <;> simp [*, Nat.succ_add]
state_before: v : Vector ℕ (Nat.succ 0 + 1)
⊢ Nat.rec (Vector.head (Vector.tail v)) (fun y IH => Nat.succ IH) (Vector.head v) =
    Vector.head v + Vector.head (Vector.tail v)
Theorem: Metric.toInductiveLimit_isometry
File: Mathlib/Topology/MetricSpace/Gluing.lean

tactic: change inductiveLimitDist f ⟨n, x⟩ ⟨n, y⟩ = dist x y
state_before: X : ℕ → Type u
inst✝ : (n : ℕ) → MetricSpace (X n)
f : (n : ℕ) → X n → X (n + 1)
I : ∀ (n : ℕ), Isometry (f n)
n : ℕ
x y : X n
⊢ dist (toInductiveLimit I n x) (toInductiveLimit I n y) = dist x y

tactic: rw [inductiveLimitDist_eq_dist I ⟨n, x⟩ ⟨n, y⟩ n (le_refl n) (le_refl n), leRecOn_self,
  leRecOn_self]
state_before: X : ℕ → Type u
inst✝ : (n : ℕ) → MetricSpace (X n)
f : (n : ℕ) → X n → X (n + 1)
I : ∀ (n : ℕ), Isometry (f n)
n : ℕ
x y : X n
⊢ inductiveLimitDist f { fst := n, snd := x } { fst := n, snd := y } = dist x y
Theorem: SimpleGraph.Walk.IsEulerian.edgesFinset_eq
File: Mathlib/Combinatorics/SimpleGraph/Trails.lean

tactic: ext e
state_before: V : Type u_1
G : SimpleGraph V
inst✝¹ : DecidableEq V
inst✝ : Fintype ↑(edgeSet G)
u v : V
p : Walk G u v
h : IsEulerian p
⊢ IsTrail.edgesFinset (_ : IsTrail p) = edgeFinset G

tactic: simp [h.mem_edges_iff]
state_before: case a
V : Type u_1
G : SimpleGraph V
inst✝¹ : DecidableEq V
inst✝ : Fintype ↑(edgeSet G)
u v : V
p : Walk G u v
h : IsEulerian p
e : Sym2 V
⊢ e ∈ IsTrail.edgesFinset (_ : IsTrail p) ↔ e ∈ edgeFinset G
Theorem: IsExtrFilter.congr
File: Mathlib/Order/Filter/Extr.lean

tactic: rw [IsExtrFilter] at *
state_before: α✝ : Type u
β✝ : Type v
γ : Type w
δ : Type x
α : Type u_1
β : Type u_2
inst✝ : Preorder β
f g : α → β
a : α
l : Filter α
h : IsExtrFilter f l a
heq : f =ᶠ[l] g
hfga : f a = g a
⊢ IsExtrFilter g l a

tactic: rwa [← heq.isMaxFilter_iff hfga, ← heq.isMinFilter_iff hfga]
state_before: α✝ : Type u
β✝ : Type v
γ : Type w
δ : Type x
α : Type u_1
β : Type u_2
inst✝ : Preorder β
f g : α → β
a : α
l : Filter α
h : IsMinFilter f l a ∨ IsMaxFilter f l a
heq : f =ᶠ[l] g
hfga : f a = g a
⊢ IsMinFilter g l a ∨ IsMaxFilter g l a
Theorem: Polynomial.eval₂_zero
File: Mathlib/Data/Polynomial/Eval.lean

tactic: simp [eval₂_eq_sum]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Semiring S
f : R →+* S
x : S
⊢ eval₂ f x 0 = 0
Theorem: BoxIntegral.Prepartition.sum_biUnion_boxes
File: Mathlib/Analysis/BoxIntegral/Partition/Basic.lean

tactic: refine' Finset.sum_biUnion fun J₁ h₁ J₂ h₂ hne => Finset.disjoint_left.2 fun J' h₁' h₂' => _
state_before: ι : Type u_2
I J J₁ J₂ : Box ι
π✝ π₁ π₂ : Prepartition I
x : ι → ℝ
πi✝ πi₁ πi₂ : (J : Box ι) → Prepartition J
M : Type u_1
inst✝ : AddCommMonoid M
π : Prepartition I
πi : (J : Box ι) → Prepartition J
f : Box ι → M
⊢ ∑ J in Finset.biUnion π.boxes fun J => (πi J).boxes, f J = ∑ J in π.boxes, ∑ J' in (πi J).boxes, f J'

tactic: exact hne (π.eq_of_le_of_le h₁ h₂ ((πi J₁).le_of_mem h₁') ((πi J₂).le_of_mem h₂'))
state_before: ι : Type u_2
I J J₁✝ J₂✝ : Box ι
π✝ π₁ π₂ : Prepartition I
x : ι → ℝ
πi✝ πi₁ πi₂ : (J : Box ι) → Prepartition J
M : Type u_1
inst✝ : AddCommMonoid M
π : Prepartition I
πi : (J : Box ι) → Prepartition J
f : Box ι → M
J₁ : Box ι
h₁ : J₁ ∈ ↑π.boxes
J₂ : Box ι
h₂ : J₂ ∈ ↑π.boxes
hne : J₁ ≠ J₂
J' : Box ι
h₁' : J' ∈ (fun J => (πi J).boxes) J₁
h₂' : J' ∈ (fun J => (πi J).boxes) J₂
⊢ False
Theorem: TopCat.pullback_snd_image_fst_preimage
File: Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean

tactic: ext x
state_before: J : Type v
inst✝ : SmallCategory J
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
U : Set ↑X
⊢ (forget TopCat).map pullback.snd '' ((forget TopCat).map pullback.fst ⁻¹' U) =
    (forget TopCat).map g ⁻¹' ((forget TopCat).map f '' U)

tactic: constructor
state_before: case h
J : Type v
inst✝ : SmallCategory J
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
U : Set ↑X
x : (forget TopCat).obj Y
⊢ x ∈ (forget TopCat).map pullback.snd '' ((forget TopCat).map pullback.fst ⁻¹' U) ↔
    x ∈ (forget TopCat).map g ⁻¹' ((forget TopCat).map f '' U)

tactic: rintro ⟨y, hy, rfl⟩
state_before: case h.mp
J : Type v
inst✝ : SmallCategory J
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
U : Set ↑X
x : (forget TopCat).obj Y
⊢ x ∈ (forget TopCat).map pullback.snd '' ((forget TopCat).map pullback.fst ⁻¹' U) →
    x ∈ (forget TopCat).map g ⁻¹' ((forget TopCat).map f '' U)

tactic: exact
  ⟨(pullback.fst : pullback f g ⟶ _) y, hy, ConcreteCategory.congr_hom pullback.condition y⟩
state_before: case h.mp.intro.intro
J : Type v
inst✝ : SmallCategory J
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
U : Set ↑X
y : (forget TopCat).obj (pullback f g)
hy : y ∈ (forget TopCat).map pullback.fst ⁻¹' U
⊢ (forget TopCat).map pullback.snd y ∈ (forget TopCat).map g ⁻¹' ((forget TopCat).map f '' U)

tactic: rintro ⟨y, hy, eq⟩
state_before: case h.mpr
J : Type v
inst✝ : SmallCategory J
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
U : Set ↑X
x : (forget TopCat).obj Y
⊢ x ∈ (forget TopCat).map g ⁻¹' ((forget TopCat).map f '' U) →
    x ∈ (forget TopCat).map pullback.snd '' ((forget TopCat).map pullback.fst ⁻¹' U)

tactic: exact ⟨(TopCat.pullbackIsoProdSubtype f g).inv ⟨⟨_, _⟩, eq⟩, by simpa, by simp⟩
state_before: case h.mpr.intro.intro
J : Type v
inst✝ : SmallCategory J
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
U : Set ↑X
x : (forget TopCat).obj Y
y : (forget TopCat).obj X
hy : y ∈ U
eq : (forget TopCat).map f y = (forget TopCat).map g x
⊢ x ∈ (forget TopCat).map pullback.snd '' ((forget TopCat).map pullback.fst ⁻¹' U)

tactic: simpa
state_before: J : Type v
inst✝ : SmallCategory J
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
U : Set ↑X
x : (forget TopCat).obj Y
y : (forget TopCat).obj X
hy : y ∈ U
eq : (forget TopCat).map f y = (forget TopCat).map g x
⊢ (forget TopCat).map (pullbackIsoProdSubtype f g).inv { val := (y, x), property := eq } ∈
    (forget TopCat).map pullback.fst ⁻¹' U

tactic: simp
state_before: J : Type v
inst✝ : SmallCategory J
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
U : Set ↑X
x : (forget TopCat).obj Y
y : (forget TopCat).obj X
hy : y ∈ U
eq : (forget TopCat).map f y = (forget TopCat).map g x
⊢ (forget TopCat).map pullback.snd
      ((forget TopCat).map (pullbackIsoProdSubtype f g).inv { val := (y, x), property := eq }) =
    x
Theorem: Real.sqrtTwoAddSeries_monotone_left
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: rw [sqrtTwoAddSeries, sqrtTwoAddSeries]
state_before: x✝ x y : ℝ
h : x ≤ y
n : ℕ
⊢ sqrtTwoAddSeries x (n + 1) ≤ sqrtTwoAddSeries y (n + 1)

tactic: exact sqrt_le_sqrt (add_le_add_left (sqrtTwoAddSeries_monotone_left h _) _)
state_before: x✝ x y : ℝ
h : x ≤ y
n : ℕ
⊢ sqrt (2 + sqrtTwoAddSeries x n) ≤ sqrt (2 + sqrtTwoAddSeries y n)
Theorem: Std.PairingHeapImp.Heap.size_tail
File: Std/Data/PairingHeap.lean

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

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

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

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

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

tactic: rfl
state_before: α : Type u_1
le : α → α → Bool
s : Heap α
h : NoSibling s
tl : Heap α
eq : tail? le s = some tl
⊢ size (Option.getD (some tl) nil) = size tl + 1 - 1
Theorem: WithTop.range_coe
File: Mathlib/Data/Set/Intervals/WithBotTop.lean

tactic: ext x
state_before: α : Type u_1
inst✝ : PartialOrder α
a b : α
⊢ range some = Iio ⊤

tactic: rw [mem_Iio, lt_top_iff_ne_top, mem_range, ← none_eq_top, Option.ne_none_iff_exists]
state_before: case h
α : Type u_1
inst✝ : PartialOrder α
a b : α
x : WithTop α
⊢ x ∈ range some ↔ x ∈ Iio ⊤

tactic: rfl
state_before: case h
α : Type u_1
inst✝ : PartialOrder α
a b : α
x : WithTop α
⊢ (∃ y, ↑y = x) ↔ ∃ x_1, Option.some x_1 = x
Theorem: Set.Finite.iUnion
File: Mathlib/Data/Set/Finite.lean

tactic: suffices (⋃ i, s i) ⊆ ⋃ i ∈ t, s i by exact (ht.biUnion hs).subset this
state_before: α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
s : ι → Set α
t : Set ι
ht : Set.Finite t
hs : ∀ (i : ι), i ∈ t → Set.Finite (s i)
he : ∀ (i : ι), ¬i ∈ t → s i = ∅
⊢ Set.Finite (⋃ (i : ι), s i)

tactic: refine' iUnion_subset fun i x hx => _
state_before: α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
s : ι → Set α
t : Set ι
ht : Set.Finite t
hs : ∀ (i : ι), i ∈ t → Set.Finite (s i)
he : ∀ (i : ι), ¬i ∈ t → s i = ∅
⊢ (⋃ (i : ι), s i) ⊆ ⋃ (i : ι) (_ : i ∈ t), s i

tactic: by_cases hi : i ∈ t
state_before: α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
s : ι → Set α
t : Set ι
ht : Set.Finite t
hs : ∀ (i : ι), i ∈ t → Set.Finite (s i)
he : ∀ (i : ι), ¬i ∈ t → s i = ∅
i : ι
x : α
hx : x ∈ s i
⊢ x ∈ ⋃ (i : ι) (_ : i ∈ t), s i

tactic: exact (ht.biUnion hs).subset this
state_before: α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
s : ι → Set α
t : Set ι
ht : Set.Finite t
hs : ∀ (i : ι), i ∈ t → Set.Finite (s i)
he : ∀ (i : ι), ¬i ∈ t → s i = ∅
this : (⋃ (i : ι), s i) ⊆ ⋃ (i : ι) (_ : i ∈ t), s i
⊢ Set.Finite (⋃ (i : ι), s i)

tactic: exact mem_biUnion hi hx
state_before: case pos
α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
s : ι → Set α
t : Set ι
ht : Set.Finite t
hs : ∀ (i : ι), i ∈ t → Set.Finite (s i)
he : ∀ (i : ι), ¬i ∈ t → s i = ∅
i : ι
x : α
hx : x ∈ s i
hi : i ∈ t
⊢ x ∈ ⋃ (i : ι) (_ : i ∈ t), s i

tactic: rw [he i hi, mem_empty_iff_false] at hx
state_before: case neg
α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
s : ι → Set α
t : Set ι
ht : Set.Finite t
hs : ∀ (i : ι), i ∈ t → Set.Finite (s i)
he : ∀ (i : ι), ¬i ∈ t → s i = ∅
i : ι
x : α
hx : x ∈ s i
hi : ¬i ∈ t
⊢ x ∈ ⋃ (i : ι) (_ : i ∈ t), s i

tactic: contradiction
state_before: case neg
α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
s : ι → Set α
t : Set ι
ht : Set.Finite t
hs : ∀ (i : ι), i ∈ t → Set.Finite (s i)
he : ∀ (i : ι), ¬i ∈ t → s i = ∅
i : ι
x : α
hx : False
hi : ¬i ∈ t
⊢ x ∈ ⋃ (i : ι) (_ : i ∈ t), s i
Theorem: Uniform.tendsto_nhds_left
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: rw [nhds_eq_comap_uniformity', tendsto_comap_iff]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.196937
inst✝ : UniformSpace α
f : Filter β
u : β → α
a : α
⊢ Tendsto u f (𝓝 a) ↔ Tendsto (fun x => (u x, a)) f (𝓤 α)

tactic: rfl
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.196937
inst✝ : UniformSpace α
f : Filter β
u : β → α
a : α
⊢ Tendsto ((fun y => (y, a)) ∘ u) f (𝓤 α) ↔ Tendsto (fun x => (u x, a)) f (𝓤 α)
Theorem: Odd.add_odd
File: Mathlib/Algebra/Parity.lean

tactic: rintro ⟨m, rfl⟩ ⟨n, rfl⟩
state_before: F : Type ?u.83706
α : Type u_1
β : Type ?u.83712
R : Type ?u.83715
inst✝¹ : Semiring α
inst✝ : Semiring β
m n : α
⊢ Odd m → Odd n → Even (m + n)

tactic: refine' ⟨n + m + 1, _⟩
state_before: case intro.intro
F : Type ?u.83706
α : Type u_1
β : Type ?u.83712
R : Type ?u.83715
inst✝¹ : Semiring α
inst✝ : Semiring β
m n : α
⊢ Even (2 * m + 1 + (2 * n + 1))

tactic: rw [two_mul, two_mul]
state_before: case intro.intro
F : Type ?u.83706
α : Type u_1
β : Type ?u.83712
R : Type ?u.83715
inst✝¹ : Semiring α
inst✝ : Semiring β
m n : α
⊢ 2 * m + 1 + (2 * n + 1) = n + m + 1 + (n + m + 1)

tactic: ac_rfl
state_before: case intro.intro
F : Type ?u.83706
α : Type u_1
β : Type ?u.83712
R : Type ?u.83715
inst✝¹ : Semiring α
inst✝ : Semiring β
m n : α
⊢ m + m + 1 + (n + n + 1) = n + m + 1 + (n + m + 1)
Theorem: Nat.preimage_Ioi
File: Mathlib/Algebra/Order/Floor.lean

tactic: ext
state_before: F : Type ?u.72433
α : Type u_1
β : Type ?u.72439
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n : ℕ
a : α
ha : 0 ≤ a
⊢ Nat.cast ⁻¹' Ioi a = Ioi ⌊a⌋₊

tactic: simp [floor_lt, ha]
state_before: case h
F : Type ?u.72433
α : Type u_1
β : Type ?u.72439
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n : ℕ
a : α
ha : 0 ≤ a
x✝ : ℕ
⊢ x✝ ∈ Nat.cast ⁻¹' Ioi a ↔ x✝ ∈ Ioi ⌊a⌋₊
Theorem: intervalIntegral.integral_Iic_sub_Iic
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: wlog hab : a ≤ b generalizing a b
state_before: ι : Type ?u.16200147
𝕜 : Type ?u.16200150
E : Type u_1
F : Type ?u.16200156
A : Type ?u.16200159
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b c d : ℝ
f g : ℝ → E
μ : MeasureTheory.Measure ℝ
ha : IntegrableOn f (Iic a)
hb : IntegrableOn f (Iic b)
⊢ ((∫ (x : ℝ) in Iic b, f x ∂μ) - ∫ (x : ℝ) in Iic a, f x ∂μ) = ∫ (x : ℝ) in a..b, f x ∂μ

tactic: rw [sub_eq_iff_eq_add', integral_of_le hab, ← integral_union (Iic_disjoint_Ioc le_rfl),
  Iic_union_Ioc_eq_Iic hab]
state_before: ι : Type ?u.16200147
𝕜 : Type ?u.16200150
E : Type u_1
F : Type ?u.16200156
A : Type ?u.16200159
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a✝ b✝ c d : ℝ
f g : ℝ → E
μ : MeasureTheory.Measure ℝ
a b : ℝ
ha : IntegrableOn f (Iic a)
hb : IntegrableOn f (Iic b)
hab : a ≤ b
⊢ ((∫ (x : ℝ) in Iic b, f x ∂μ) - ∫ (x : ℝ) in Iic a, f x ∂μ) = ∫ (x : ℝ) in a..b, f x ∂μ

tactic: exacts [measurableSet_Ioc, ha, hb.mono_set fun _ => And.right]
state_before: case ht
ι : Type ?u.16200147
𝕜 : Type ?u.16200150
E : Type u_1
F : Type ?u.16200156
A : Type ?u.16200159
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a✝ b✝ c d : ℝ
f g : ℝ → E
μ : MeasureTheory.Measure ℝ
a b : ℝ
ha : IntegrableOn f (Iic a)
hb : IntegrableOn f (Iic b)
hab : a ≤ b
⊢ MeasurableSet (Ioc a b)

case hfs
ι : Type ?u.16200147
𝕜 : Type ?u.16200150
E : Type u_1
F : Type ?u.16200156
A : Type ?u.16200159
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a✝ b✝ c d : ℝ
f g : ℝ → E
μ : MeasureTheory.Measure ℝ
a b : ℝ
ha : IntegrableOn f (Iic a)
hb : IntegrableOn f (Iic b)
hab : a ≤ b
⊢ IntegrableOn (fun x => f x) (Iic a)

case hft
ι : Type ?u.16200147
𝕜 : Type ?u.16200150
E : Type u_1
F : Type ?u.16200156
A : Type ?u.16200159
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a✝ b✝ c d : ℝ
f g : ℝ → E
μ : MeasureTheory.Measure ℝ
a b : ℝ
ha : IntegrableOn f (Iic a)
hb : IntegrableOn f (Iic b)
hab : a ≤ b
⊢ IntegrableOn (fun x => f x) (Ioc a b)

tactic: rw [integral_symm, ← this hb ha (le_of_not_le hab), neg_sub]
state_before: case inr
ι : Type ?u.16200147
𝕜 : Type ?u.16200150
E : Type u_1
F : Type ?u.16200156
A : Type ?u.16200159
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b c d : ℝ
f g : ℝ → E
μ : MeasureTheory.Measure ℝ
ha : IntegrableOn f (Iic a)
hb : IntegrableOn f (Iic b)
this :
  ∀ {a b : ℝ},
    IntegrableOn f (Iic a) →
      IntegrableOn f (Iic b) →
        a ≤ b → ((∫ (x : ℝ) in Iic b, f x ∂μ) - ∫ (x : ℝ) in Iic a, f x ∂μ) = ∫ (x : ℝ) in a..b, f x ∂μ
hab : ¬a ≤ b
⊢ ((∫ (x : ℝ) in Iic b, f x ∂μ) - ∫ (x : ℝ) in Iic a, f x ∂μ) = ∫ (x : ℝ) in a..b, f x ∂μ
Theorem: cast_eq_iff_heq
File: Mathlib/Logic/Basic.lean

tactic: cases h
state_before: a✝¹ a✝ : Sort u_1
e : a✝¹ = a✝
a : a✝¹
a' : a✝
h : HEq a a'
⊢ cast e a = a'

tactic: rfl
state_before: case refl
a✝ : Sort u_1
a : a✝
e : a✝ = a✝
⊢ cast e a = a
Theorem: Equiv.Set.sumDiffSubset_symm_apply_of_not_mem
File: Mathlib/Logic/Equiv/Set.lean

tactic: apply (Equiv.Set.sumDiffSubset h).injective
state_before: α✝ : Sort u
β : Sort v
γ : Sort w
α : Type u_1
s t : Set α
h : s ⊆ t
inst✝ : DecidablePred fun x => x ∈ s
x : ↑t
hx : ¬↑x ∈ s
⊢ ↑(Set.sumDiffSubset h).symm x = Sum.inr { val := ↑x, property := (_ : ↑x ∈ t ∧ ¬↑x ∈ s) }

tactic: simp only [apply_symm_apply, sumDiffSubset_apply_inr]
state_before: case a
α✝ : Sort u
β : Sort v
γ : Sort w
α : Type u_1
s t : Set α
h : s ⊆ t
inst✝ : DecidablePred fun x => x ∈ s
x : ↑t
hx : ¬↑x ∈ s
⊢ ↑(Set.sumDiffSubset h) (↑(Set.sumDiffSubset h).symm x) =
    ↑(Set.sumDiffSubset h) (Sum.inr { val := ↑x, property := (_ : ↑x ∈ t ∧ ¬↑x ∈ s) })

tactic: exact Subtype.eq rfl
state_before: case a
α✝ : Sort u
β : Sort v
γ : Sort w
α : Type u_1
s t : Set α
h : s ⊆ t
inst✝ : DecidablePred fun x => x ∈ s
x : ↑t
hx : ¬↑x ∈ s
⊢ x = inclusion (_ : t \ s ⊆ t) { val := ↑x, property := (_ : ↑x ∈ t ∧ ¬↑x ∈ s) }
Theorem: Multiset.sum_nat_mod
File: Mathlib/Algebra/BigOperators/Multiset/Basic.lean

tactic: induction s using Multiset.induction <;> simp [Nat.add_mod, *]
state_before: ι : Type ?u.169674
α : Type ?u.169677
β : Type ?u.169680
γ : Type ?u.169683
s : Multiset ℕ
n : ℕ
⊢ sum s % n = sum (map (fun x => x % n) s) % n
Theorem: LinearMap.coprod_inr
File: Mathlib/LinearAlgebra/Prod.lean

tactic: ext
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.67812
M₆ : Type ?u.67815
S : Type ?u.67818
inst✝¹³ : Semiring R
inst✝¹² : Semiring S
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M₂
inst✝⁹ : AddCommMonoid M₃
inst✝⁸ : AddCommMonoid M₄
inst✝⁷ : AddCommMonoid M₅
inst✝⁶ : AddCommMonoid M₆
inst✝⁵ : Module R M
inst✝⁴ : Module R M₂
inst✝³ : Module R M₃
inst✝² : Module R M₄
inst✝¹ : Module R M₅
inst✝ : Module R M₆
f✝ : M →ₗ[R] M₂
f : M →ₗ[R] M₃
g : M₂ →ₗ[R] M₃
⊢ comp (coprod f g) (inr R M M₂) = g

tactic: simp only [map_zero, coprod_apply, inr_apply, zero_add, comp_apply]
state_before: case h
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.67812
M₆ : Type ?u.67815
S : Type ?u.67818
inst✝¹³ : Semiring R
inst✝¹² : Semiring S
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M₂
inst✝⁹ : AddCommMonoid M₃
inst✝⁸ : AddCommMonoid M₄
inst✝⁷ : AddCommMonoid M₅
inst✝⁶ : AddCommMonoid M₆
inst✝⁵ : Module R M
inst✝⁴ : Module R M₂
inst✝³ : Module R M₃
inst✝² : Module R M₄
inst✝¹ : Module R M₅
inst✝ : Module R M₆
f✝ : M →ₗ[R] M₂
f : M →ₗ[R] M₃
g : M₂ →ₗ[R] M₃
x✝ : M₂
⊢ ↑(comp (coprod f g) (inr R M M₂)) x✝ = ↑g x✝