Agnishom

{-# LANGUAGE FlexibleContexts #-}

import Control.Monad
import Control.Monad.State

type NonDet a = [a]

type NonDetState s a = StateT s [] a

type Vertex = Int

Agnishom

I am a final year undergraduate student of Mathematics and (Theoretical) Computer Science studying in Chennai Mathematical Institute, India. My interests in computer science are along the lines of programming languages and logic.

My interest in functional programming began as a leisure activity, but became more serious when I took my first introductory Haskell Course. As time progressed, I educated myself through the means of several internet blogs and other online resources. I also took a follow up course titled "Implementation of Functional Programming" where we discussed the challenges of the implementational aspects of languages with functional abstraction. In the subsequent year, I offered to be the teaching assistant of the same introductory Haskell course which was my initial inspiration. Not only did I tutor this course in my institution, but also over online courses conducted by NPTEL, twice in a row.

Last summer, I interned at a technological start-up VacationLabs, Goa where we used functional p

Agnishom

• Link to post problems: https://brilliant.org/newsfeed/create/problem/
• Link to post discussions: https://brilliant.org/newsfeed/create/note/
• Last Year's wiki: https://brilliant.org/wiki/tessellate-stems/
• This year's wiki: https://brilliant.org/wiki/tessellate-stems-2019/
• MathJax Crash Course: http://www.mathisfunforum.com/viewtopic.php?id=4397
• CodeCogs Equation Editor: https://www.codecogs.com/latex/eqneditor.php

Agnishom

Symbolic Analysis Using SMT Solvers (SASS)
Instructor: M.K. SrivasFirst
Meeting: Aug 8 (Wed) 3:30PM, Lec Hall 801

Satisfiability-Modulo Theory (SMT) solver is a sound algorithmic framework for combining automatic decision procedures for first-order (i.e., quantifier-free) theories of data types, such as propositional logic, un-interpreted functions, bit-vectors, arithmetic, arrays, pointers, etc.,  that commonly occur in modern programming languages.  Advances in SMT solving technology in the recent past have enabled development of tools - interactive theorem provers, model checkers, guided-synthesizers - for practical formal verification and synthesis of sequential and concurrent SW systems. This course covers the theory and practice of SMT solvers providing hands-on exposure to the use of SMT solvers.  The topics of the course will be distributed over two not necessarily contiguous parts.  The first part will cover the basic principles and theory behind construction of SMT solvers, describing in detail dec

Agnishom

import Page exposing (..)
import Http
import Json.Decode as Decode
import Task
import Html

main =
  Html.program
    { init = init
    , view = view

Agnishom

update : Msg -> Model -> (Model, Cmd Msg, Maybe LoadingCounter)
update =
    case msg of
        Produce cmd -> (model, cmd, Just Increment)
        Consume -> (model, Cmd.none, Just Decrement)
        msg ->
            let
                (newModel, newCmd) = realUpdate msg model
            in
                (newModel, newCmd, Nothing)

Agnishom

module AnalyticPage exposing (..)

import AutoGen exposing (..)
import Navigation
import Http
import Array
import Html exposing (..)
import Html.Attributes exposing (..)
import FileReader
import Json.Decode

Agnishom

import AutoGen exposing (..)
import Html exposing (..)
import Html.Attributes exposing (..)
import Html.Events exposing (..)
import Http
import Json.Decode as Decode
import Platform.Cmd


main =

Agnishom

import Control.Monad.Random

arbitrarySet :: Monad m => m Bool -> [a] -> m [a]
arbitrarySet getBool = flip foldr (return []) $ \x ls -> do
                                                    t <- getBool
                                                    l <- ls
                                                    if t
                                                      then return (x:l)
                                                      else return l

Agnishom

{-# LANGUAGE NoMonomorphismRestriction #-}
{-# LANGUAGE FlexibleContexts          #-}
{-# LANGUAGE TypeFamilies              #-}

import Diagrams.Prelude
import Diagrams.Backend.SVG.CmdLine

rules :: Diagram B
rules = foldr1 (<>) hands
    where